{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "QjFkqyzBFxuJ"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "!pip install mujoco==2.3.3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "%env MUJOCO_GL=egl"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## **Importing Required Libraries**\n",
        "\n",
        "This cell imports essential libraries for implementing and visualizing Deep Deterministic Policy Gradient (DDPG) and Soft Actor-Critic (SAC). The key components include:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "cgl1dhmOFhny"
      },
      "outputs": [],
      "source": [
        "from   torch.optim import Adam\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from   torch.distributions import Normal\n",
        "import random\n",
        "import numpy as np\n",
        "import logging\n",
        "import matplotlib\n",
        "import matplotlib.pyplot as plt\n",
        "import imageio\n",
        "from IPython.display import HTML\n",
        "from base64 import b64encode\n",
        "import gymnasium as gym\n",
        "\n",
        "\n",
        "\n",
        "is_ipython = 'inline' in matplotlib.get_backend()\n",
        "if is_ipython:\n",
        "    from IPython import display\n",
        "\n",
        "\n",
        "\n",
        "logging.getLogger().setLevel(logging.ERROR)\n",
        "\n",
        "# set up matplotlib\n",
        "plt.ion()\n",
        "plt.xkcd(scale=1, length=100, randomness=2)\n",
        "matplotlib.rcParams['figure.figsize'] = (12, 6)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## **Logging, Visualization, and Video Playback Functions**\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "8qtiUS5-BrE5"
      },
      "outputs": [],
      "source": [
        "def plot_rewards(sum_of_rewards, show_result=None , bove = None,dn = None):\n",
        "    plt.figure(1)\n",
        "    rewards = torch.tensor(sum_of_rewards, dtype=torch.float)\n",
        "    if show_result is not None:\n",
        "        plt.title(f'{show_result}')\n",
        "    else:\n",
        "        plt.clf()\n",
        "        plt.title('Training...')\n",
        "    if bove is not None:\n",
        "        plt.xlabel(f'{bove}')\n",
        "    else:\n",
        "        plt.xlabel('Episode')\n",
        "    if dn is not None:\n",
        "        plt.xlabel(f'{dn}')\n",
        "    else:\n",
        "        plt.ylabel('Reward')\n",
        "    plt.plot(rewards.numpy())\n",
        "    # Take 50 episode averages and plot them too\n",
        "    length = len(rewards)\n",
        "    init_len = min(49, length)\n",
        "    init_means = np.cumsum(rewards[:init_len]) / (1 + np.arange(init_len))\n",
        "    if length > 50:\n",
        "        means = rewards.unfold(0, 50, 1).mean(1).view(-1)\n",
        "        means = torch.cat((init_means, means))\n",
        "    else:\n",
        "        means = init_means\n",
        "    plt.plot(means.numpy())\n",
        "\n",
        "    plt.pause(0.001)  # pause a bit so that plots are updated\n",
        "    if is_ipython:\n",
        "        if not show_result:\n",
        "            display.display(plt.gcf())\n",
        "            display.clear_output(wait=True)\n",
        "        else:\n",
        "            display.display(plt.gcf())\n",
        "def show_video(path):\n",
        "    mp4 = open(path, 'rb').read()\n",
        "    data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n",
        "    return HTML(\"\"\"\n",
        "    <video width=400 controls>\n",
        "          <source src=\"%s\" type=\"video/mp4\">\n",
        "    </video>\n",
        "    \"\"\" % data_url)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## **Replay Memory for Experience Replay**\n",
        "\n",
        "This class implements a **Replay Buffer**, a crucial component in off-policy reinforcement learning algorithms like DDPG and SAC. The buffer stores past experiences and allows the agent to sample them randomly, breaking correlation between consecutive samples and improving learning stability."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "MutuNBENU9jS"
      },
      "outputs": [],
      "source": [
        "class ReplayMemory:\n",
        "    def __init__(self, capacity, seed):\n",
        "        random.seed(seed)\n",
        "        self.capacity = capacity\n",
        "        self.buffer = []\n",
        "        self.position = 0\n",
        "\n",
        "    def push(self, state, action, reward, next_state, done):\n",
        "        if len(self.buffer) < self.capacity:\n",
        "            self.buffer.append(None)\n",
        "        self.buffer[self.position] = (state, action, reward, next_state, done)\n",
        "        self.position = (self.position + 1) % self.capacity\n",
        "\n",
        "    def sample(self, batch_size):\n",
        "        batch = random.sample(self.buffer, batch_size)\n",
        "        state, action, reward, next_state, done = map(np.stack, zip(*batch))\n",
        "        return state, action, reward, next_state, done\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.buffer)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## **Neural Networks for DDPG and SAC**\n",
        "\n",
        "This cell defines key neural networks used in **Deep Deterministic Policy Gradient (DDPG)** and **Soft Actor-Critic (SAC)** algorithms.\n",
        "\n",
        "\n",
        "- **`GaussianPolicy`**: A stochastic policy for SAC, using Gaussian action sampling.\n",
        "- **`DeterministicPolicy`**: A deterministic actor for DDPG, applying action bounds."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UEUENTmKVZTo"
      },
      "outputs": [],
      "source": [
        "# Initialize Policy weights\n",
        "def weights_init_(m):\n",
        "    if isinstance(m, nn.Linear):\n",
        "        torch.nn.init.xavier_uniform_(m.weight, gain=1)\n",
        "        torch.nn.init.constant_(m.bias, 0)\n",
        "\n",
        "\n",
        "class ValueNetwork(nn.Module):\n",
        "    def __init__(self, num_inputs, hidden_dim):\n",
        "        super(ValueNetwork, self).__init__()\n",
        "\n",
        "        self.linear1 = nn.Linear(num_inputs, hidden_dim)\n",
        "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
        "        self.linear3 = nn.Linear(hidden_dim, 1)\n",
        "\n",
        "        self.apply(weights_init_)\n",
        "\n",
        "    def forward(self, state):\n",
        "        x = F.relu(self.linear1(state))\n",
        "        x = F.relu(self.linear2(x))\n",
        "        x = self.linear3(x)\n",
        "        return x\n",
        "\n",
        "\n",
        "class QNetwork(nn.Module):\n",
        "    # Todo12\n",
        "    def __init__(self, num_inputs, num_actions, hidden_dim):\n",
        "        super(QNetwork, self).__init__()\n",
        "\n",
        "       # TODO 1 -> Define two separate Q-networks (Q1 and Q2) for twin Q-learning.\n",
        "        pass \n",
        "\n",
        "\n",
        "        self.apply(weights_init_)\n",
        "\n",
        "    def forward(self, state, action):\n",
        "        # TODO 2 -> Concatenate state and action as input and compute Q-values for both Q-networks.\n",
        "        pass \n",
        "        return Q1, Q2\n",
        "\n",
        "\n",
        "LOG_SIG_MAX = 2\n",
        "LOG_SIG_MIN = -20\n",
        "epsilon = 1e-6\n",
        "\n",
        "class GaussianPolicy(nn.Module):\n",
        "    def __init__(self, num_inputs, num_actions, hidden_dim, action_space):\n",
        "        super(GaussianPolicy, self).__init__()\n",
        "\n",
        "        self.linear1 = nn.Linear(num_inputs, hidden_dim)\n",
        "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
        "\n",
        "        self.mean_linear = nn.Linear(hidden_dim, num_actions)\n",
        "        self.log_std_linear = nn.Linear(hidden_dim, num_actions)\n",
        "\n",
        "        self.apply(weights_init_)\n",
        "\n",
        "        \n",
        "        # TODO 3 -> Compute action scaling and shifting factors based on the environment's action space.\n",
        "        pass\n",
        "\n",
        "    def forward(self, state):\n",
        "        x = F.relu(self.linear1(state))\n",
        "        x = F.relu(self.linear2(x))\n",
        "        mean = self.mean_linear(x)\n",
        "        log_std = self.log_std_linear(x)\n",
        "        log_std = torch.clamp(log_std, min=LOG_SIG_MIN, max=LOG_SIG_MAX)\n",
        "        return mean, log_std\n",
        "\n",
        "    def sample(self, state):\n",
        "         # TODO 4 -> Use the reparameterization trick to sample from the Gaussian policy and apply action bounds.\n",
        "        pass\n",
        "\n",
        "        y_t = torch.tanh(x_t)\n",
        "        action = y_t * self.action_scale + self.action_bias\n",
        "        log_prob = normal.log_prob(x_t)\n",
        "        # Enforcing Action Bound\n",
        "        log_prob -= torch.log(self.action_scale * (1 - y_t.pow(2)) + epsilon)\n",
        "        log_prob = log_prob.sum(1, keepdim=True)\n",
        "        mean = torch.tanh(mean) * self.action_scale + self.action_bias\n",
        "        return action, log_prob, mean\n",
        "\n",
        "\n",
        "\n",
        "class DeterministicPolicy(nn.Module):\n",
        "    def __init__(self, num_inputs, num_actions, hidden_dim, action_space=None):\n",
        "        super(DeterministicPolicy, self).__init__()\n",
        "        self.linear1 = nn.Linear(num_inputs, hidden_dim)\n",
        "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
        "\n",
        "        self.mean = nn.Linear(hidden_dim, num_actions)\n",
        "        self.noise = torch.Tensor(num_actions)\n",
        "\n",
        "        self.apply(weights_init_)\n",
        "\n",
        "       # TODO 5 -> Compute action scaling and shifting factors for deterministic policy.\n",
        "        pass\n",
        "    def forward(self, state):\n",
        "        x = F.relu(self.linear1(state))\n",
        "        x = F.relu(self.linear2(x))\n",
        "        mean = torch.tanh(self.mean(x)) * self.action_scale + self.action_bias\n",
        "        return mean\n",
        "\n",
        "    def sample(self, state):\n",
        "         # TODO 6 -> Generate an action by adding noise to the deterministic policy for exploration.\n",
        "        pass\n",
        "        return action, torch.tensor(0.), mean\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## **Soft Actor-Critic (SAC) Implementation - Explanation of the Cell**\n",
        "\n",
        "This cell implements the **Soft Actor-Critic (SAC) algorithm**, a state-of-the-art off-policy reinforcement learning method for continuous control. The key idea behind SAC is to maximize both the **expected reward** and the **entropy** of the policy, promoting exploration and robustness.\n",
        "\n",
        "### **Main Components in This Cell**\n",
        "1. **Hyperparameters & Configuration**  \n",
        "   - The algorithm's key parameters such as **discount factor** ($\\gamma$), **soft update factor** ($\\tau$), and **entropy coefficient** ($\\alpha$) are set from the `config` dictionary.\n",
        "   - **Entropy tuning** is optionally enabled to adjust $\\alpha$ dynamically.\n",
        "\n",
        "2. **Critic (Q-Networks)**\n",
        "   - Two separate **Q-networks** (`self.critic` and `self.critic_target`) estimate the action-value function.\n",
        "   - Using **twin Q-learning** (two critics) reduces overestimation bias.\n",
        "\n",
        "3. **Actor (Policy Network)**\n",
        "   - **Gaussian policy** is used when `policy_type=\"Gaussian\"`, meaning actions are sampled from a probability distribution instead of being deterministic.\n",
        "   - The policy is trained to maximize both expected rewards and entropy.\n",
        "   - If the deterministic version (DDPG-like) is used, entropy is ignored ($\\alpha = 0$).\n",
        "\n",
        "4. **Action Selection (`select_action`)**\n",
        "   - If `evaluate=False`, actions are sampled from the stochastic policy.\n",
        "   - If `evaluate=True`, deterministic actions are chosen for testing.\n",
        "\n",
        "5. **Parameter Update (`update_parameters`)**\n",
        "   - **Sample a batch** from replay memory.\n",
        "   - Compute **target Q-values** using the **minimum of the two Q-networks**.\n",
        "   - Update **critic networks** by minimizing Bellman loss.\n",
        "   - Update **policy** using the entropy-regularized objective.\n",
        "   - If entropy tuning is enabled, update **$\\alpha$** using.\n",
        "   - Periodically **soft update** the target Q-network.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "V_DNPHq2Vwex"
      },
      "outputs": [],
      "source": [
        "\n",
        "class SAC(object):\n",
        "    def __init__(self, num_inputs, action_space, config):\n",
        "\n",
        "        self.gamma = config['gamma']\n",
        "        self.tau = config['tau']\n",
        "        self.alpha = config['alpha']\n",
        "\n",
        "        self.policy_type = config[\"policy\"]\n",
        "        self.target_update_interval = config[\"target_update_interval\"]\n",
        "        self.automatic_entropy_tuning = config['automatic_entropy_tuning']\n",
        "\n",
        "        self.device = torch.device(\"cuda\" if config['cuda'] else \"cpu\")\n",
        "\n",
        "        self.critic = QNetwork(num_inputs, action_space.shape[0], config['hidden_size']).to(device=self.device)\n",
        "        self.critic_optim = Adam(self.critic.parameters(), lr=config['lr'])\n",
        "\n",
        "        self.critic_target = QNetwork(num_inputs, action_space.shape[0], config[\"hidden_size\"]).to(self.device)\n",
        "        self.hard_update(self.critic_target, self.critic)\n",
        "\n",
        "        if self.policy_type == \"Gaussian\":\n",
        "            # Target Entropy = −dim(A) (e.g. , -6 for HalfCheetah-v2) as given in the paper\n",
        "            # TODO 7: Compute the target entropy for the Gaussian policy and initialize log_alpha for automatic entropy tuning.\n",
        "            pass\n",
        "            # TODO 7: The target entropy is typically set to -|A| (where A is the action space dimension), and log_alpha is initialized for optimization.\n",
        "\n",
        "            self.policy = GaussianPolicy(num_inputs, action_space.shape[0], config[\"hidden_size\"], action_space).to(self.device)\n",
        "            self.policy_optim = Adam(self.policy.parameters(), lr=config[\"lr\"])\n",
        "\n",
        "        else:\n",
        "            self.alpha = 0\n",
        "            self.automatic_entropy_tuning = False\n",
        "            self.policy = DeterministicPolicy(num_inputs, action_space.shape[0], config[\"hidden_size\"], action_space).to(self.device)\n",
        "            self.policy_optim = Adam(self.policy.parameters(), lr=config['lr'])\n",
        "\n",
        "    def select_action(self, state, evaluate=False):\n",
        "        state = torch.FloatTensor(state).to(self.device).unsqueeze(0)\n",
        "        if evaluate is False:\n",
        "        # TODO 8: Decide whether to sample from the policy or use the deterministic policy based on the evaluate flag.\n",
        "            pass\n",
        "        else:\n",
        "        # TODO 8: When evaluating, we typically use the deterministic policy, while during training, we use the exploration-based policy (stochastic).\n",
        "            pass\n",
        "\n",
        "        return action.detach().cpu().numpy()[0]\n",
        "\n",
        "    def update_parameters(self, memory, batch_size, updates):\n",
        "        # Sample a batch from memory\n",
        "        state_batch, action_batch, reward_batch, next_state_batch, mask_batch = memory.sample(batch_size=batch_size)\n",
        "\n",
        "        state_batch = torch.FloatTensor(state_batch).to(self.device)\n",
        "        next_state_batch = torch.FloatTensor(next_state_batch).to(self.device)\n",
        "        action_batch = torch.FloatTensor(action_batch).to(self.device)\n",
        "        reward_batch = torch.FloatTensor(reward_batch).to(self.device).unsqueeze(1)\n",
        "        mask_batch = torch.FloatTensor(mask_batch).to(self.device).unsqueeze(1)\n",
        "\n",
        "        with torch.no_grad():\n",
        "            next_state_action, next_state_log_pi, _ = self.policy.sample(next_state_batch)\n",
        "            qf1_next_target, qf2_next_target = self.critic_target(next_state_batch, next_state_action)\n",
        "            min_qf_next_target = torch.min(qf1_next_target, qf2_next_target) - self.alpha * next_state_log_pi\n",
        "            next_q_value = reward_batch + mask_batch * self.gamma * (min_qf_next_target)\n",
        "\n",
        "\n",
        "        # TODO 9: Compute the Q-value loss using the Bellman backup and target Q-values.\n",
        "        pass\n",
        "        # TODO 9: The loss is typically the mean squared error between the Q-value predicted by the critic and the target Q-value.\n",
        "\n",
        "        self.critic_optim.zero_grad()\n",
        "        qf_loss.backward()\n",
        "        self.critic_optim.step()\n",
        "\n",
        "        pi, log_pi, _ = self.policy.sample(state_batch)\n",
        "\n",
        "        # TODO 10: Compute the policy loss by taking the minimum of the two Q-values and using the entropy bonus term.\n",
        "        pass\n",
        "\n",
        "        policy_loss = ((self.alpha * log_pi) - min_qf_pi).mean() \n",
        "\n",
        "        self.policy_optim.zero_grad()\n",
        "        policy_loss.backward()\n",
        "        self.policy_optim.step()\n",
        "\n",
        "\n",
        "\n",
        "        if self.automatic_entropy_tuning:\n",
        "            # TODO 12: Compute the loss for tuning the entropy coefficient α.\n",
        "                pass\n",
        "            # TODO 12: The alpha loss encourages the entropy to be close to the target entropy, optimizing the entropy coefficient automatically.\n",
        "\n",
        "        else:\n",
        "            alpha_loss = torch.tensor(0.).to(self.device)\n",
        "            alpha_tlogs = torch.tensor(self.alpha) # For TensorboardX logs\n",
        "\n",
        "\n",
        "        if updates % self.target_update_interval == 0:\n",
        "            self.soft_update(self.critic_target, self.critic, self.tau)\n",
        "\n",
        "        return qf1_loss.item(), qf2_loss.item(), policy_loss.item(), alpha_loss.item(), alpha_tlogs.item()\n",
        "\n",
        "\n",
        "    # Hard and Soft updates\n",
        "    # TODO 13: Implement soft update for target networks using Polyak averaging.\n",
        "    def soft_update(self, target, source, tau):\n",
        "        pass\n",
        "    # TODO 13: Soft update blends the target network with the source network using a factor tau, updating target gradually.\n",
        "\n",
        "    def hard_update(self,target, source):\n",
        "        for target_param, param in zip(target.parameters(), source.parameters()):\n",
        "            target_param.data.copy_(param.data)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## **Environment Setup and Initialization for SAC**\n",
        "\n",
        "This cell sets up the environment and initializes the components needed to train the **Soft Actor-Critic (SAC)** agent.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QdbiGFaAX_HF",
        "outputId": "2e04b648-f206-489f-bd0c-f05fa8a828d0"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.11/dist-packages/gymnasium/envs/registration.py:519: DeprecationWarning: \u001b[33mWARN: The environment HalfCheetah-v4 is out of date. You should consider upgrading to version `v5`.\u001b[0m\n",
            "  logger.deprecation(\n"
          ]
        }
      ],
      "source": [
        "# Configuration dictionary\n",
        "config = {\n",
        "    \"env_name\": \"HalfCheetah-v4\",\n",
        "    \"policy\": \"Gaussian\",\n",
        "    \"gamma\": 0.99,\n",
        "    \"tau\": 0.005,\n",
        "    \"lr\": 0.0003,\n",
        "    \"alpha\": 0.2,\n",
        "    \"seed\":123456,\n",
        "    \"automatic_entropy_tuning\": False,\n",
        "    \"batch_size\": 256,\n",
        "    \"num_steps\": 1000001,\n",
        "    \"hidden_size\": 256,\n",
        "    \"updates_per_step\": 1,\n",
        "    \"start_steps\": 10000,\n",
        "    \"target_update_interval\": 1,\n",
        "    \"replay_size\": 1000000,\n",
        "    \"cuda\": False,\n",
        "    \"eval_interval\": 1,\n",
        "}\n",
        "\n",
        "# Setup environment\n",
        "env = gym.make(config[\"env_name\"])\n",
        "env.action_space.seed(config[\"seed\"])\n",
        "\n",
        "# Set random seeds\n",
        "torch.manual_seed(config[\"seed\"])\n",
        "np.random.seed(config[\"seed\"])\n",
        "\n",
        "# Initialize agent\n",
        "agent = SAC(env.observation_space.shape[0], env.action_space, config)\n",
        "\n",
        "# Initialize replay memory\n",
        "memory = ReplayMemory(config[\"replay_size\"], config[\"seed\"])\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## **Training Loop for SAC Agent**\n",
        "\n",
        "This cell contains the **training loop** for the Soft Actor-Critic (SAC) agent. The loop runs for a set number of episodes, where in each episode, the agent interacts with the environment, collects experiences, and updates its parameters."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "Y10BjpyhRX6C",
        "outputId": "40ec8edd-5405-490e-d6b6-2a1bc6699540"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Episode: 0, reward: -31.55\n",
            "Episode: 10, reward: -112.72\n",
            "Episode: 20, reward: 846.59\n",
            "Episode: 30, reward: 1285.29\n",
            "Episode: 40, reward: 2391.1\n",
            "Episode: 50, reward: 394.84\n",
            "Episode: 60, reward: 3598.89\n",
            "Episode: 70, reward: 3747.9\n",
            "Episode: 80, reward: 4296.65\n",
            "Episode: 90, reward: 4355.67\n",
            "Episode: 100, reward: 5206.81\n",
            "Episode: 110, reward: 5444.87\n",
            "Episode: 120, reward: 5926.32\n",
            "Episode: 130, reward: 5924.64\n",
            "Episode: 140, reward: 6337.59\n",
            "Episode: 150, reward: 6468.78\n",
            "Episode: 160, reward: 6593.62\n",
            "Episode: 170, reward: 6865.97\n",
            "Episode: 180, reward: 6751.2\n",
            "Episode: 190, reward: 7187.12\n",
            "Episode: 200, reward: 7216.13\n",
            "Episode: 210, reward: 7368.13\n",
            "Episode: 220, reward: 7656.23\n",
            "Episode: 230, reward: 7591.69\n",
            "Episode: 240, reward: 7491.71\n",
            "Episode: 250, reward: 7605.28\n",
            "Episode: 260, reward: 7808.89\n",
            "Episode: 270, reward: 7983.79\n",
            "Episode: 280, reward: 7991.15\n",
            "Episode: 290, reward: 8206.69\n",
            "Episode: 300, reward: 8026.1\n",
            "Episode: 310, reward: 8466.68\n",
            "Episode: 320, reward: 8427.29\n",
            "Episode: 330, reward: 8636.24\n",
            "Episode: 340, reward: 8779.51\n",
            "Episode: 350, reward: 8548.4\n",
            "Episode: 360, reward: 9104.64\n",
            "Episode: 370, reward: 8834.28\n",
            "Episode: 380, reward: 9228.26\n",
            "Episode: 390, reward: 9274.42\n",
            "Episode: 400, reward: 9506.48\n",
            "Episode: 410, reward: 9224.47\n",
            "Episode: 420, reward: 9390.99\n",
            "Episode: 430, reward: 9660.88\n",
            "Episode: 440, reward: 9668.9\n",
            "Episode: 450, reward: 9796.37\n",
            "Episode: 460, reward: 9639.12\n",
            "Episode: 470, reward: 10267.88\n",
            "Episode: 480, reward: 9845.8\n",
            "Episode: 490, reward: 9818.03\n"
          ]
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABBsAAAI3CAYAAADa/FOzAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd8FGX+wPHP7iabttn0npCE3qQ3aSIiFuy9K/Z23lnO8yxnv/PO+531TuyKXRRsKIKCCEjvvYf03jfZbJvfH8NMdrObhigEvu/XKy92Z54pOzvMzvOd5/k+BkVRFIQQQgghhBBCCCEOE+OR3gEhhBBCCCGEEEIcWyTYIIQQQgghhBBCiMNKgg1CCCGEEEIIIYQ4rCTYIIQQQgghhBBCiMNKgg1CCCGEEEIIIYQ4rCTYIIQQQgghhBBCiMNKgg1CCCGEEEIIIYQ4rCTYIIQQQgghhBBCiMMq6EjvgBBCiN9feXk5paWlBAUFkZSURFRU1O+6fY/HQ3l5ORUVFYSGhpKSkkJoaOjvug8vv/wyW7du5eqrr2bs2LG/67YP1WeffcaPP/7IlClTuPDCCzu9/G233QbA3//+d2JiYg737v0m7rjjDjweD08//TSxsbFHend+cwsWLGD27NmMHDmS66+/3m++x+Nh5cqVfP/995SWlqIoCmeddRbTpk0LuD6Px0NZWRmVlZWEhYWRkpJCSEhIwLKzZ89mwYIFTJ48mYsvvviwfq6u5oMPPmDp0qWcccYZnHPOOUd6d4QQokuSlg1CCHGcqKmp4dFHH2XIkCEkJCQwYMAA+vTpQ3R0NCkpKVxwwQXMmjWr3fU4HA4GDRpEdnY2AwcOpKmpqcP7kJOTw6OPPkpWVhZJSUn079+f7t27Y7VaOfHEE/nvf/9LQ0PDr/mYHTZ37lxmzJjBjh07fpftHQ7Lly9nxowZLF++3Gd6U1MTixcvZvHixSiK0uryM2bMYMaMGdhstt96Vw+bV1999Xfd540bN5KdnU12djZlZWVtlv373/9OdnY2l1566WHd/owZM/jxxx/95nk8Hi666CLGjh3L448/ziuvvMKMGTNYu3atX9l9+/bx8MMPk5GRQXJyMv379yc7O5vIyEjGjx/Pq6++it1u91lGO7+WLVt22D7Pb0k75ztzDeqon3/+mRkzZrB69erDut7169fr51d7f88888xh3bYQQvzepGWDEEIcBwoLC5k4cSJ79+4FICMjgx49emA2m8nNzWXnzp3MmTOH0tLSdp9ofv3112zevFl//9VXX7W7jMvl4t577+Wll17SK8M9e/YkIyMDu93O7t27WbFiBStWrOBf//oXGzZs6DJP3o8GFRUVTJo0CQC3243BYDiyO9SFORwOcnJyAPVYtqWqqoqcnBwyMjJ+hz1TK8Bz5swhJiaGGTNm0L9/f4KCgoiPj9fLOJ1O/vCHP/Dqq6/q03r37k1aWhqNjY3s2rWLZcuWsWzZMv75z3+yadMmLBbL77L/h5t2zufl5ZGenn5kd6aDmpqa9POrPVVVVb/tzgghxG9Mgg1CCHEceOKJJ9i7dy/JycnMnDmTKVOm+FRIy8vLmT17Nhs2bGh3XW+//TYA2dnZ7N+/n7feeqvNYIOiKNx000288847AFx33XXcfvvtjBgxQt8Hj8fDihUrePrpp/n222+x2WwSbAjgySef5OGHH261GfyxSGtd8Ht39TkaffvttwBcccUVXHLJJX7zFUXh6quv5pNPPgHgpptu4tZbb2XYsGF6GbfbzbJly3jqqadYsGABTU1NXTbY0NXt2rXLJ1DU0vH0/1wIcWySYIMQQhzj6urqePfddwF45plnOPXUU/3KxMfHc/PNN7e7rsLCQr777jsMBgOffPIJY8aMYf78+eTn57f6ZPHzzz/XAw0vv/wyd9xxh18Zo9HI2LFjmTt3Lm+++SbBwcGd+ITHj/DwcMLDw4/0bvyuJOjUTAu8JCcnB5z/wQcf6IGGN998M2DOB5PJxMSJE/n++++ZMWMGJpPpt9th0abo6Gg5v4UQxzTJ2SCEEMe4/Px8vW/2yJEjf9W6Zs6cicfjYcqUKYwcOZJTTz0Vj8fDzJkzW13mzTffBGDKlCncfvvt7W7jhhtuICkpqcP7tGXLFp588kmmTp1KdnY2CQkJ9O7dm9tvv/1X9T3fs2cPN998M1lZWWRkZHDqqafy2WefAfDQQw8xffp0tm3bFnDZ3NxcHnroIfr3709SUhJ9+/blL3/5C/v37291W9OnT+fee+8F4Mcff+T888+nR48eJCcns2bNGgA+/vhjpk+frlcoAV577TXuvvtu/f3111/P9OnT9T9t2Zb27dvHzTffTJ8+fUhOTuaUU07hk08+wePxBCw7ffp0fTs//vgjZ599NpmZmfTo0YNrrrlG76IDsHv3bm666Sb69etHSkoKZ599NkuWLGn1WLflhhtuYPr06VRUVPhMf++995g+fTqfffYZLpeLl156iRNPPJGUlBT69u3LI488QlFR0SFt83AoLi7mf//7HxdeeCH9+vUjMTGRzMxMPTeKw+Ho8Lpef/11pk+frh/D2bNn69+vd/BO+7921llnBQw0eDMYDNx2221ER0cHnO92u5kxYwbjxo0jJSWF3r1789e//pX8/Pw211tYWMiTTz7J4MGDSUpKomfPntx5551s2bKlzeWampr4+OOPOfXUU8nIyCA9PZ0zzjiDOXPm4HK5fMp++umnTJ8+XX9/zz33+JzzCxYs0Ofl5+fzwgsvcN5559GnTx8SEhLIysrisssu48svv/RbdyAul4sXXniBMWPG6OfX3/72N4qLi9td9nCaMWMG06dP59tvv8XhcPDss88ycuRIkpOTGTBgAE899RTl5eU+yxQUFDB9+nSuv/76NvPh7N+/n+nTp3PjjTf+JjkwhBDHKUUIIcQxraCgQAEUQHnnnXcOeT0ej0fp1auXAijvv/++oiiK8sEHHyiA0rNnT8Xj8fgtU1ZWpphMJgVQ3nzzzUPedlsyMzMVQDEYDEpqaqqSnp6uGAwG/TPff//9AZc7/fTTW92v9957TzEajQqghISEKL169VIiIyMVQHnggQeUfv36KYDyww8/+C07Y8YMfVmz2axkZmYqISEh+j4+99xzfsv88ssvCqBkZGQo//nPf/R9Dw8PVwDlp59+UhRFUe655x4FUO6991592SuvvFIvH+jvs88+08tq02bNmqVYrVYFUOLi4hSz2azPu+uuu/z2b+XKlQqgpKamKi+//LICKEFBQUp8fLy+XGJiorJv3z7l559/1tcdHx+vBAUF6Z/de186Sjt/cnNzfabffvvt+rGYOnWqAihhYWFKTEyMvk9paWlKUVFRp7a3atUqffn2lr3vvvsUQJkwYYLfvOuvv15fT1xcnJKVleVznMePH680NDT4Lffss88qgHLFFVfo066++upWv9/o6GhFUdT/59p5/8EHH3TqM7f8PHfccYdyzjnn6Mc0NjbW53tu+V1oXnjhBf37Cg4OVrKysvT/N4Dy9NNPB1xu48aNSkZGhl4uNTVVSU1N1d+PHTtWqa6u1svff//9bZ7zL7zwgl72ggsu0KcnJCQomZmZSnBwsD7t9NNPVxwOh98+3XzzzQqg/PnPf1ZOOeUU/f9jdHS0vmx6erpSUlLSqWO8fPlyffnS0tJOLXv55ZcrgPLoo48qY8eOVQAlIiJCiYqK0tfZo0cPpaqqSl/G4/Eo3bt397luB/LII4/ox0MIIQ4XCTYIIcRx4MQTT1QAJSoqSvm///s/JT8/v9PrWLp0qQIoFotFqa+vVxRFUWw2m16Z+Pnnn/2Wef311/Wb4OLi4l/9OQK58cYblS+++EKpra3VpzU0NCgvvviiEhoa2uq+tRZs2LFjhx4cuPXWW/XKhM1mU/71r38pJpNJn98y2PDzzz/rFb7bbrtNX7a8vFz505/+pB+LefPm+SynBRtCQkIUk8mk3HXXXUpOTo6iKIpSUVGhVFRUKIoSONjgdruVvLw8fd1Op1Nxu936n3cQSCtjsViUyy+/XNm+fbuiKIpSV1enPP744/r83bt3++yfFmwwm81KSEiI8vTTTyuVlZWKoijK1q1blUGDBimAcvbZZyupqanKFVdcoa+jrKxMueKKKxRAycrKChiUakt7wQaLxaJkZGQon3/+ueJwOBSPx6MsWbJEr7zefffdndre4Qo2PPPMM8qMGTOUwsJCfZrb7Va+/fZbJTs7WwGUxx57zG+5QMEG7bu85pprFEB54oknfL5jRVGUl156SQEUk8mkfzedpX0ei8WipKSkKJ988onS1NSkKIqirFixQq+03nLLLX7Lfvrpp/o5/Pzzz+v7YLfblbfeeksPnH333Xc+y5WVlemBhUsvvVTZunWrPm/VqlXKsGHDFEC5+uqr/Y6H9j0dOHCg1XP+0UcfVd58802foIDL5VJmz56tb/f555/3+zxasMFisSiZmZnKnDlzFKfTqXg8HmXx4sVKWlqaHozojMMRbLBYLEqvXr2UuXPnKi6XS/F4PMqCBQuUhIQE/fzw9sQTTyiAcuqppwZcr9vt1oO2H3/8caf2SQgh2iLBBiGEOA4sXrxYCQsL83n617NnT+Xyyy9XXn755Q49/dWe1E6fPt1n+g033KAAynXXXee3zF/+8hf9CfOR8OSTTyqA8oc//MFvXmvBBq3CNXXq1IAVY++nqi2DDdpT1IsuuijgsldddZUCKKeddprPdC3YoAUpWhMo2KAovq1XtMpnIFqZk08+2W//PB6PMmrUKAVQXnrpJZ95WrABUB5++GG/9c6dO1efP27cOL99KC8v18+/HTt2tLp/gbQXbACUzZs3+y337rvvKoDSt2/fTm3PO9iQmJiopKSktPqnVaADBRvaon3f/fv395sXKNigufbaaxVAeeqpp/zm/fGPf9T/Xx8q7dwHlFWrVvnNnzVrlgIo3bp18zl/PB6P3trn1VdfDbhuLRhy7rnn+kx/6qmnFECZNGlSwHO3sLBQCQkJUYKDg/2CKNq+5uXlHcKnbT5vx44d6zdPCzYYDAZl27ZtfvPffPNNBVAGDhzYqW16BxvaO7+2bNnis6wWbAgODlb279/vt+7nn39eAZQTTzzRZ3pOTo7+WQIdq0WLFunB6MbGxk59HiGEaIvkbBBCiOPAxIkT2bBhAzfddBOhoaGAmifgo48+4s477yQrK4ubb7651aHW6uvr9TwB11xzjc+8a6+9FoBZs2ZRV1fnM6+6uhoAq9V6OD9Oh51//vkAfPfddx1e5uuvvwbUzxloCMmrr7464HKNjY3MmzcPgFtvvTXgsrfeeisACxcupKamJuB6brzxxg7v66G66aab/PbPYDAwZcoUAFatWtXqst595TXjx4/3mW80+t5exMXFMWDAgHbXfSjGjRvHwIED/aZrn2XHjh1+52VHlZaWUlRU1OpfW33g2zJmzBiSkpLYtm0bubm5h7SOlrT/u4fj/9rQoUMD5nfRjmlubi6lpaX69C1btrB9+3YSEhL060FLV111FcHBwcybN8/n+9CuK/fdd5/feQOQkpLCmWeeidPp5Msvv/xVn6ul008/ndDQUJYvX65fq1qaMGEC/fr185uuHYstW7Yc8nnQ3vnVWj6J0047jaysrFb3adWqVfoQwwCZmZlMnjwZRVF47733/JbTEvhefvnl+u+DEEIcDjIahRBCHCd69+7Na6+9xv/93/+xfPly1qxZw5IlS1i0aBFNTU28/vrrrFq1iuXLlxMWFuaz7KxZs7DZbGRmZjJx4kSfeePGjdOHwZw1a5ZPYrqIiAgAPUHlb0FRFObNm8e3337LkiVLKCsrw+l0AmqSO4CSkpIOrauyspKdO3cCaiUjkAEDBhAbG0tlZaXP9NWrV9PQ0IDZbGbcuHEBlx01ahQRERHYbDaWLVvGmWee6TPfYrEwZMiQDu3rr9FaotCUlBQAamtrA86PjY2le/fuftMjIyMJDQ3FbrczfPjwgMtqST8PteLfmlGjRrW5PVA/T2RkZKfXrQ0X25oHH3yQF154odX5mzZt4rPPPuOnn34iJyfH5/+BlvCypKSEbt26dXrfWtL+rzU2Nv7qdbV2TKOiovTvuba2Vj/Gc+fOBSAxMZGPP/5Yr+i2/NdisVBVVcWePXsYOnQoeXl5bN68GVATFGqV3pbLacetvSSTrVmzZg2zZ8/mp59+Ii8vzycBorbusrKygMkyWzsW2v8VUM/pQxklJicnh4SEhFbnt1bxb+//r9vtprGx0WefrrvuOhYuXMi7777LAw88oAcb6+vr9cS31113Xac/gxBCtEWCDUIIcZyJjIxk6tSpTJ06FVCfiP7xj3/kvffeY+PGjcyePZsrr7zSZ5m3334bgFNPPZV9+/b5rXPq1Km8+uqrvP322z7BBq2iVlhYSGNjo18Q49dyu91cdtll+s1yXFwc6enpREdHYzabaWxsZOnSpR3O/O/d2iA+Pj5gGYPBQFxcnF+wQas8xsXFtVpJCA4OJikpiX379vmNrgBqZS7Q093DrbX9CwpSbwu8n4p2ZDmDwaAve6jrPlStbc9kMmE0GvF4PIe8zfaGGm1riNYXX3yRP/3pTyiKQlhYGNnZ2WRmZur/B5YsWYLdbu/UqBRt0SqaeXl5OBwOzGbzIa+rI9+z9zHVgnlbt27tUIVVCzh5BwH/8Ic/dHi5znjyySf529/+BqgBmezsbGJiYvTPuHDhQtxud6vfQ3vnMxz6OX2oQ9keyj5dcMEF3H777ezcuZOVK1cyZswYQB2a2Gaz0a9fv1YDK0IIcagk2CCEEMe5mJgY3nzzTZYvX86ePXv47LPPfIINu3bt0ofce+ONN3jjjTdaXdfSpUvZtWsXvXv3BmDatGncf//9NDU1sXDhQqZNm3ZY9/2rr77is88+Izk5mY8++ogJEyZgMpn0+Tt37qRv374dXp/2dBjAZrO1WhGor6/3mxYSEgLQbuVRm6+V9/Z7BBrEb6+kpIT7778fRVF44403uPzyy/3OpfT0dAoKCg7bNs866yz+9re/UV9fz5IlSzjllFMO27rbowVdTj75ZB5++OF2yw8aNMhnOYD58+f7/N8NJDU1tVP7tXfvXh599FGCgoKYOXMm559/vl9FPSIi4pC7QXQlERERXHzxxbz99tu8++67erDh3XffBdRWDYG6fgkhxK8hwQYhhBAEBwczfPhw9uzZ49MXG5r788bFxelBhED27NlDWVkZ77zzDn//+98B6N+/P4MGDWLTpk188cUXhz3Y8NZbbwFw//33M2nSJL/5WpeIjoqPjyc5OZni4mJWrlzJWWed5VcmNzeXoqIiv+k9evQA1BYOeXl5ZGRk+JUpKSkhPz/fp/zhdrhbDojO+/DDD2lqamLatGnccMMNfvOrq6s73LWno4YMGULv3r3ZtWsXX3755e8abOjVqxegnt8nn3xyhyutmZmZBAcH43Q6SUhIOOQuRK2d8zNnzkRRFC699FIuv/xyv/n5+fnHRaBBc9111/H222/z8ccf89xzz1FSUsKiRYswGo1cddVVR3r3hBDHIHmEIoQQAkVR2L17N+DbF9ntdutPvv72t7/xyy+/tPqnBRjeffddPVcCoN/kv/vuu6xdu7bdfdmxY0eryRNbKi4uBiAtLS3g/M8//7xD69EYjUY9wDB79uyAZebMmRNwep8+fejTpw8A3377bcAyWqLK9PR0hg0b1ql9a4t3KwmbzXbY1isOjRZIaO28/Oqrr1pN/neoDAaD/n/ttdde61B+gy1bthyW8+XCCy/EbDazbds2VqxY0eHloqOj9QBkWy2mWqOd9619hva+h9b+jx+rxo8fT/fu3amuruarr75i5syZgJpwsrOtRoQQoiMk2CCEEMe4/Px8LrjgAlasWBHwCaCiKLz55pusW7cOwCfnwvz58yksLMRkMnHppZe2uR2twlFYWMj8+fP16X/84x854YQTcDqdTJ06lVmzZukJHL05HA5efvllRo0a1eG+2doT1UBZ6n/88Uc++OCDDq3HmzbaxDvvvMNbb72Fx+PR5/300096/+9ALr74YgCeeOIJvybyJSUlPProo3q5w9lkOSYmhsTERAD9exRHjnZeLliwwK8iXFBQ0KGuBofivvvuo2/fvjQ1NTF58mTmzJkTMKhht9t5/vnnGT169GFJ3hobG8sFF1wAqCOutNZqw+Fw8PPPP/tM01p+vPbaa22OGrNy5Uq/xKVaF6nWgpja9/Ddd9/5dW/au3cvTz31VKvbOxYZjUZ9tJB33nlHDzZIYkghxG9FulEIIcQxTlEU5syZw5w5c+jZsycnnXQSvXv3JiQkhIKCAhYsWMCGDRsAdWSJ008/XV9W66YwZcoUn+z+gcTExHDmmWfyxRdf8NZbb3HGGWcAEBYWxty5c5k2bRqbN2/mkksuITk5mUsuuYSMjAzsdju7du1i3rx5lJWVYTAY2u27rbnxxhv56KOP+PDDD7Hb7Zx33nmEhIQwZ84cZs2axYQJE/jpp586dbwmTpzIn//8Z5599lluuOEG/v3vfzNs2DD27t3LihUrmDZtGnv27GHnzp1+AYP777+fWbNmsXPnTgYMGMAdd9zB4MGD2bp1Ky+99BJVVVVkZ2fzyCOPdGqf2mM0Gpk2bRpvv/02Z599NqeccgqxsbEYDAZuv/32VkeIEL+Niy++mLvvvpv9+/czbtw4br31VhITE1mxYgWvv/46SUlJJCUlHfauFBaLhW+//ZZp06axfft2LrjgAtLS0rj44otJS0ujsbGRnTt3Mm/ePCoqKjAajYctT8iLL77I6tWr2bRpE7179+bCCy/k5JNPJiQkhNLSUtasWcM333zDgAEDWLx4sb7ctGnTuO2223jllVeYNm0akyZN4oILLiA5OZm6ujq2b9/OvHnz2Lx5M3l5eT5De5599tls3LiR66+/no8++oiEhASMRiOXX345U6ZM4corr+TBBx9k8+bNTJw4kRtuuIG4uDgWL17MW2+9Re/evWlsbAyYg+X3MGXKlDaTjI4cOZJXXnnlsG7zmmuu4dFHH9UDO9HR0ZxzzjmHdRtCCKGRYIMQQhzjYmJiuO222/jiiy/Ys2cPe/bsCVjmqquu4umnn9YrH+Xl5XqLgZajU7Tmyiuv5IsvvuDLL7+kvLxcH9EhIyOD5cuX8/777/PGG2+wZs0aXnzxRZ9lTSYT5557Lo8++qhPV462TJ48mX/84x88+uijzJ4926dZ9PTp0/nzn/9M//79O7Qub//85z8ZMWIE//jHP9iwYQPbt28nOjqa+++/nyeeeELvLtFyOMXIyEgWL17MPffcw6xZs/SuJaBmir/44ot57rnniImJ6fQ+tefZZ5/F5XIxd+5cn5YeZ555pgQbfmdWq5XZs2dzxRVXsHHjRm677TZ93qhRo/j444+ZMmXKb7Lt7OxsVq5cyXvvvccbb7zB+vXref75533KBAUFccEFF/DYY48dtnMxISGBlStX8vDDD/Pxxx/z9ttv66PYaOLi4jjttNN8phkMBv773/8yaNAgXnrpJRYtWsSiRYt8yphMJs444wy//28PPPAAlZWVzJ49Wx9+E2Dw4MFMmTKF5ORkPv30U6677jpWrlzJypUr9TKTJk3igw8+YODAgYfl8x+KTZs2tTk/KirqsG8zKyuLk08+WT/Gl19+eaujWwghxK9lUCSTlBBCHBcURWHPnj1s2bJFHx4vMjKSESNGMGTIEL/WBA0NDRQWFgLQrVu3Dg2l53Q6OXDgAKBmjm9tNIdNmzaxfv16KioqCAsLo1u3bowZM4a4uLhD+mxVVVXMnTuXkpISEhISmDhxIllZWfr+GAwGv4SMhYWFNDQ0kJiY6PO01JuiKJSXl+N2u0lMTMRoNFJaWkpycjJGo5GysrJWK2ulpaV8++23VFRUEBMTwxlnnNFqEKWxsZGCggKCgoLIyspq9XOWl5dTXV1NdHR0q0Nzut1uiouLaWxsBNThRy0WC4AeaMrKyvIZJk9TU1NDWVkZERERPvtqt9vJz8/HZDKRnZ0dcLt79+5FUZRWz5WioiJsNhvx8fFER0e3+hlb0vZZSyaoKSsro6amhpiYmFbPm/Y+byDaZ+3Ictr3ERoaSnp6ut98h8PBggUL2LlzJ5GRkQwePJiRI0diMBjIycnB5XKRlpbmMyRsVVUVFRUVWCwWfehYTUlJCXV1dcTGxhIbG9uhz7N+/Xo2btxIRUUF4eHhZGVlMWbMmIDnrfZ5oqKiSEhICLi+9r5nUI/h/Pnz9c+YkJDAwIEDGTRoUJutlhRFYd26daxZs4a6ujoiIyPp2bMnI0eObPX/qLZccXGx3mWl5Tlmt9uZN28ee/fuJTo6muHDhzN48GAMBgP79u3D4/GQkZHhk/uktLSU2traVs8vRVHYu3cvcOjnV3vCwsJ88k0UFxdTX19PXFxcwO/P4/HoQxN379691VYrFRUVVFVVAbR5/RNCiF9Lgg1CCCFEJ7z00kvcddddTJo0ye8JrBBCCCGEUEmCSCGEEKKFDz/8kGXLlvkkh2xsbOTdd9/lgQceAOCyyy47UrsnhBBCCHHUk5wNQgghRAuLFi3ijTfeIDY2ll69emEwGNi6das+Ssall17KTTfddIT3UgghhBDi6CXBBiGEEKKFK664ApvNxtq1a9myZQsOh4PY2FjOO+88rrzySk499dTDlsVfCCGEEOJYJDkbRJekKAputxuXy4Xb7dana8PQmUwmgoODpTLwO/F4PLhcLjweD4qi+DQ9NxqNmM3mDg9lKJopioLD4cDlcunTDAYDQUFBBAcH+w27KNrn8XhwOBx+52hQUBAmk0mO6WGiKAoulwun04l2m2EymeQ4HyKPx4Pb7cbtdvudu9pxlWN6+Gjnr/a7BujDhMq9xeHn8XhwOp36PYR31USuG78d7X7N+/7N+9hr1xeTyYTRaJTjfxhox1z7c7vd+jHXjvGxdk2Xlg1dlKIo1NbWEhoaitls7hInpKIo2O12amtrqayspLCwkJKSEsrLy6mtrcVms1FdXU1lZSWVlZXU1dXR1NSEw+HA6XTicDhoaGjAZrNht9t9brhao90YaJWz4OBgwsPDiYmJISoqisjISKKjo4mIiMBqtRITE0NoaCihoaFERET4lImPjyciIoKIiAhCQkK6xDHXOJ1O6urq9ONXV1dHcXEx5eXl2Gw2fVp9fT2NjY3Y7XZ97HFtOe3P4XDQ1NREU1MTTqfTpzLRlqCgIJ9jGxISgtls1o+z9hcZGUlUVBRWq5XExESSkpJISEggMTGRuLi4Do2IcKS43W5KS0uprKykoqKCwsJCqqqq9GNcX19PQ0MDdXV1+vHWjnFdXR12ux2n04ndbqepqandczw4OJiwsDAiIyOxWq1YLBasVivR0dFYrVaioqL019HR0cTGxhIVFYXFYiEyMpKEhARiYmK6xLlss9koLy+ntLSUgoIC8vPz9az9Wtb4hoYG7Ha7fp43NTVhs9lobGzE6XT6BG0CMRgMnHvuufz3v/8lNTW1zbJlZWUsWrSIXbt2ERsbS3Jysn5stWNtsVgIDQ3tEsfXm6IoOJ1OysvLqaqqorGxkZqaGv06bbPZKCsro7i4mLKyMv2vpqZGP6/bOtYGgwGz2UxwcDAWi0U/blFRUcTGxhIeHk5ERASxsbFER0cTHR1Neno6CQkJREVFERcXR1RUVJeo8DU2NlJZWUlVVRWFhYUUFBRQWlpKTU0NDQ0N+nW2oaGBmpoaKisr9WNss9n03z7voHprTCYTISEh+l/L64N2bENCQrBarSQlJenHUrsmxMfHExcXh8Vi6XK/c263m7KyMvLy8qioqPD5XbPb7fp5W1FRQX19PTabTb8eNzQ00NTUpH8n7f2uafcSYWFhWCwWIiIiCA0NxWKxEB4ejtVqJSEhQb8OaNfgqKgokpKSSEtL6zLXXo3H49HP19raWqqrq6mrq/M5rlVVVfq5rV2LGxsbqauro7a2FrvdjsPhwOFw6L9zWpChI4xGI6GhoYSFhen3D+Hh4YSHh/tcQ7TzWbun0O7jvO/pkpOTOzyCyNGmoaGBiooK6urqKCsr068bVVVVVFZWUl1drV+Pteu2dr+h3UM3NTVht9s7dP+m0e7btGu0dsy1e+PY2FhSUlJISEjQp2nfhXYdiomJITIysksde5fLRUlJiX6ctfO6oaFBP/dLS0spKiqipqZGv0/WvoPGxkaf+kxHmUwm/bfS+/fSarVitVr1uov3NSYhIUG/B0lNTSUuLo7IyMjf5FqjBUzaCwRKy4YuqqmpSR8X2WAw6BdY7eKq/QBqN2pWq5W4uDhiY2OJiIggLCxMvyEJCwvTK3/aDYoWwddaEGg3PE6nU79gaTf02g+J9qPjfcNZUlKi/wesrKxs92a/qwgLCyMhIQGLxUJMTIxeEdb+42s/atpNnHbjFhYWRmhoqE/wwztqrN08a0+vtONut9v1H2mbzaZf2LSgTH19PRUVFfoNlnZDoP3gaEPgdXUGg4H4+HiSkpJISkoiIiKC6OhofRgwbbgz78CR94U6NDSUkJAQnyi9wWDQz3OHw0FjY6N+TmvHUgu0aBUArWJQUVFBcXExxcXFFBYWUlZW1qkf7qNBUFCQfvzCw8NJSEjQbxS0HzAtSBEXF0d0dDTh4eEEBwdjNpsJDQ3Vj6/29AnQn8K6XC49ONXY2Eh1dbXPzb9246pVbLX32k2SVgGrra39XY/JxIkTGT9+PH379iUxMZHg4GBqamrYuXMns2fPZvny5R1aV2hoKElJSfo1WqvweV+zvW/arFYr4eHhesXF+xz2PmcBn5ZEWisCLVilBQ1ra2v1m3ztxlSrbDU2Nuo3p9o5XlNTQ01NzVF/rQ4KCiI1NZXExES9sqEd17i4OKxWKyEhIURERBAZGalXsr0rh9rvndls9vnt046vdl3QKqE2m00PlmvnqPabV1VVpf/elZSUUFZWpgfMuypt6E3tPNR+y7TfPe2aERkZSUxMDFarVb+f0K4L3hXDoKAgn+Pr/WTP5XLpv3Xa/URdXZ1egdXO16amJn16eXk5NTU1+kOK3/MacTiYTCYiIiKIi4sjJSVFv054V9BavteuF2FhYT73E9r9Q8vrg3Zsva8PTqeTxsZGnwqodm2uqqrSAwnaOV5WVqYHyToaFOgKjEYjMTExesXM+7dO+x3U7iu0ip32wES7Xngf+5b3FNqf9/HXKpze98/asdbunVsGyLTrTH19vX6tqampOdKH71czmUx6kMhisei/j9o57n0vrQVArVarPl+7D/G+/9COf8v7Ou/zXrsfqamp0Y9zY2MjtbW1VFVVUVVVRXV1NSUlJRQWFlJcXExFRcWRPly/isFgIDY2lsTERJ8AnRa0iI6OJjExUb+ua7+PWjntPkRrNe59LTcYDFitVgk2HItqamo6NU750UQ7MVNSUvSom3frAu2CY7VaMZvNPn9aNNX75qVlRE2r5LS8yGh/DQ0NeiW9rq6OmpoaPSJcU1OjV+wbGhr0yL32ZKor3zhC89MY7al2YmKifuOt/ZhqNzDaTbl2o649xdEqmN4/ttqf9l1oFyGtIqRd5LVjqz111oIn2g2j9n1oP7zeN+8VFRVdoiKv3cDExMSQmppKfHy8z1MA7fhHRkb63EBqN/TBwcE+gT/tAq8ForSKpfZEyDvYpwWYtAqmdk57/4hqP7Dase5KQkJCiI+PJz09nbS0NP3aobUq0H4UteOtVTZbBkS0c9VoNOoVHq2yowX4tNd2u11/GqSdw9px1I5heXk5JSUl1NbWUl9fr9+wd3XauRwWFqbfkHi3OkhNTdVvyrWnKdq5rF2ftQq8d9c37+PrHVzSbvK0G/GKigo9qKe1ZNGCVV2JyWTSz9P09HSSkpL046pdZ7UbPy1orf1p1wDv64D2r3ZMvX/vtKeV2vVBq7xrgWftiXN1dTWlpaVUVFToTz5ra2spKyvr0ueu0WgkOTlZ/23TKiZai7q4uDj9QYF20+0djNJ+57TrsHZTDfhcK7QgtBbY154We7dSKS0tpbq6Wr+/0AJV2hPSrspgMOjBUS0YEhMTo1fOo6Oj9XNbu3fQfue0SkvL+wjv89u7EuMdMNHOc61yqN0/eH8P2jVC+03UrhfatVqbV11dfdQHVNsTHBxMZGQkcXFxestb7eFLVFSU3oLAO6Dtfa5rgRPtoZd30ASag63ad+D926hdo7UAiPa6oqKCoqIi/cGX9uf9AKGhoeEIH7lDExQUpFfEtetEeHg4sbGxJCQkEB8fT1paGtHR0XoA2/sBsNYqxGw2+1zHva/n2gME7Zz3ftDr/Xupndfae+0cr6ys1K/h2oPe36PeUl9fT0REROvH7jffA/GbsFqt+pNCrZmmdyVDq4BoP3DaDZvWpNs7uqdFuJuamtq8+GoRLS0K6V3x976gaZEyi8VCQkKC/sOfmJioV2i7QvPXQLRgRVlZmX5stSda2rHVKneVlZX6BaC+vl4/1lpT+Y42HdS6H2gXKi0CnJiYqAdltCdN2k2U9hTKu2VLZGQkwcHBv8NR+m14PB7KysooKSmhqKiI8vJyPXCk/Xk/6dL+H3hXbDrSNUG74dRuRr1vmLQKgHfFICkpidTUVP3fuLi4LtM80G63U15erjeBt9ls+rms3UBXV1frT7y064zWvFurzLTXLFC7cdeePGvnqHfribi4OL+nF95dQbSAQlfhdrv1a4V2fLVrsNaiwPs4ewfatAqh9tSlI03oobnbmHYTGRoaqjcZ1q4J2k2RxWIhLCxMvzn1bhmgVSCO1qauTU1NlJaWkp+f79OsVavklZeX660KtGOrNZP3rhx6N2tt7xhrT+y1VlNac2ztfNWuv8nJyXogVzuW7T31Odq4XC79WlBaWurXEkm7qdWCF7W1tT6tZbSKt3crm452tfO+n4iMjNQfPmjnq3YDr10vtCefsbGxxMTEEBsbe1Sesy1p921aF4SioiK9O5h3JU57qu1dYdPu4bTft44wGAw+T4G181m7nwsLC9OPo/d5qx3r1NRUUlNT9cpqV72H03g8Hr11qPa75v1XWlpKeXm5fl+hHXftgUl798uBGI1G/UGCdj+h3Uto92neT+61a7Z2zL2vNVrAsityOBz6taKhocHnmqLdu2n3HlrFWruf9v4/0NDQoN+HtEfLHabdS4eGhurHWnu4pl1voqOj9RYt6enpeh0mLi6uy+UeUxRFb7WhndPe3aK141lRUaHXa7S6jBZU0u5HtO58gc779n7fpGVDF1ZeXk5OTg5xcXFkZ2cflnVqT6G9b7wk2eJvx7sZqRbRhOZEVN5PVcSv5x0x1qLIklT08NCi8N7J1LRWBF2ponU0apk8zZt3Mik5dw+d9uTO+xhrx1auC7+O1pS85e+cdny1a4VcJzovUHI/7/sIuTb8dlo++W+ZXFFrnSHfwW9P66oSKLmoXL8PL+167n2s28sdKMGGLmzmzJlce+21TJ06le+///5I744QQgghhBBCiGNcSUkJu3fvJiYmhgEDBrRaTkI9XVhdXR0AkZGRR3hPhBBCCCGEEEIcDz777DMmTJjAo48+2mY5CTZ0YTabDaDNpBxCCCGEEEIIIcTh0tF6qAQbujAtw2hISMgR3hMhhBBCCCGEEMeDjtZDJdjQhWnDU0k3CiGEEEIIIYQQv4eO1kMl2NCFVVRUABAfH3+E90QIIYQQQgghxPGgo/VQCTZ0YTU1NQBdaux5IYQQQgghhBBdV0froRJs6MIaGhoACA8PP8J7IoQQQgghhBDieNDReqgEG7owCTYIIYQQQgghhPg9SbDhOKB9yTL0pRBCCCGEEEKI30NH66ESbOjCSktLAYiNjT3CeyKEEEIIIYQQ4njQ0XqoBBu6KI/HQ2FhIQDp6elHeG+EEEIIIYQQQhzrOlMPlWBDF1VTU4PL5QIgMTHxCO+NEEIIIYQQQohjXWfqoRJs6KK0sU0tFgshISFHeG+EEEIIIYQQQhzrOlMPlWBDF6WNbRodHX1kd0QIIYQQQgghxHGhM/VQCTZ0UWVlZQDExMQc4T0RQgghhBBCCHE86Ew9VIINXVR+fj4gySGFEEIIIYQQQvw+OlMPlWBDF1VdXQ1AXFzckd0RIYQQQgghhDiCVu2v5KyXlvDKT3uP9K4c8zpTDw36jfdF/Ea0LzkqKurI7ogQQgghhBBCHEGXvLocgC0FtdwysTtGo+EI79GxqzP1UGnZ0EVVVlYC0rJBCCGEEEIIITQSaPhtdaYeKsGGLspmswEQERFxhPdECCGEEEIIIY4Mu9P9m6x3b1k9V72xkvtmbSSvsuE32QaAx6OwYFsJK/dV/GbbOJw6Uw+VbhRdVEODesKHh4cf4T0RQgghhBBCiCOjsLrR573Ho/zq1g0ut4c/fLiebUW1AHy1sZCnzxvIxSMyftV6A/l+azG3fbAOgwE+vmkMo7sf3S3XO1MPPSpbNtTU1LBo0SKeffZZ7rrrLu666652l7HZbPzzn/9k3LhxjBo1ij/96U8UFxe3Wl5RFBYsWMBZZ53FsGHDOPfcc1m8eHGb28jPz+eOO+5g5MiRTJgwgeeeew673d5qeYfDwYwZMzjppJMYMWIEN954I/v27Wv3s3SE1nylI+ObCiGEEEIIIcSx6ECFb6uDygbHr17nJ2vy9EADgMPl4aE5W6hpdPqVXbW/khvfXc1jX23F7VE6va25m4sAUBS48d01h77Tv5PO1EOPumDDd999R3R0NJMnT+b+++/npZde4qWXXmpzmT179tC7d28eeOABbDYbYWFhvPDCC3Tv3p1vv/3Wr7zb7ebyyy9n6tSprFq1ivj4eJYuXcqkSZO4/vrrURT/k+Tzzz+nZ8+evPLKK1gsFqqqqrjnnnvo27cvubm5fuXLysoYPHgwt912G8XFxURFRfHuu+/Sp08f3nrrrUM/QAfV1NQAHRvfVAghhBBCCCGORbktujhU2X5dsKGmwcm/v9/pN93h9vD9Ft+H2f9dtIdLXl3OD9tLeeeXHL99ac3S3eUs3V2Ooig4XB59el2Tiy83FPyq/f+tdaYeetQFG0JCQjj77LN57LHH+Prrr4mPj2+zvKIoXHfddRQWFvLSSy+xfv16Fi9ezE8//YTBYODqq6/WD4jmrbfe4pNPPuHUU09l586dzJ8/nx07djBx4kTefvttPvroI5/y5eXlXHfddYSEhLBs2TIWLVrEpk2b+Ne//sWBAwe46aab/PbrrrvuYseOHfz1r39l69at/Pjjj6xZs4a4uDhuvfVWcnJyftVxqq+vByAyMvJXrUcIIYQQQgghuqqCFt0oyuqbftX6Xly4m6oGtQXD2YNTmXP7WH3eZ2vz9deKovDCD7t9lo2NMLe7/hX7KrjqzZVc9eZK/jp7s1/LjD9+vCHgw++jRWfqoUddsGHy5Ml89dVXPProo5x11lkEBwe3WX7r1q0sW7aMMWPGcOedd2IwqP1zTjrpJG655RYqKyuZNWuWzzIzZswA4OWXX9YjMgkJCbz44osAvPLKKz7lP/zwQ+rr67nzzjs58cQTATAajdx3330MHjyY+fPn+3SPqKys5JNPPiEjI4OnnnqKoCA1NcbgwYP5y1/+gtPp5O233z7UQwQ0R5SsVuuvWo8QQgghhBBCdFVFNb7d2ktrDz3YkFNuY+byHABCgoz89Yy+DMmIpmeiBYBVOZXkV6nBAYPBQESISV+2R0IEUWFt110BFu8q019/vDqPnSV1fmWW7ik/5M/wW+tMPbTLJ4hcunQpAOedd57fvHPPPZfnnnuOZcuWceONNwJQV1fHhg0b6NevH7179/YpP2jQIDIzM1m9ejVNTU2EhIS0uQ2DwcC5557Lxo0bWbZsGd27dwdg+fLlKIrCOeecg9HoG88599xzueeee1i2bFmrn+mhhx4CICwsDKvVSmhoKMHBwURERHDSSSeRlJSkR5QsFktHDpMQQgghhBBCHHNadl0oqW09p14gNQ1OSuvs9Ey08O/5O3G61VYFN0/sTmp0GACn9k9iT6la/9pTWk96jJoc0e5s7gLRkUADwNbC2oDTDQaY2j+J0dlxjMyK7dRn+D11ph7a5YMNv/zyC6C2GmhJm6aVAVi1ahUejydgeYPBwODBgzlw4ADr169nzJgxPssPGjSozW1cffXV7e5T9+7dsVgsrFixArfbjclk8ivzzDPP4PF4/KYDfPPNN0ybNg2nU23a017LDyGEEEIIIYToKhRF0Vurd6Ts/rJ6n2m1dv8kjq2ptTs57fmfKa61MyQjmg151QDERZi55aQeernUqFD9dVldc8uJRq9hN8PNHata7ygKHGy4YlQ3nj7/hA7v+5HSmXroUdeNorPy8vIAiI31j/5ERUVhMpnIz8/vUHmAuDh1qBFtGY/HQ0FBAREREXpLh7bKe79uaxs2m80vlwSo/2FaCzSA+qUqioLDoSY+MZvb7xckhBBCCCGEEEcrRVH4emMhE/61kFP+bzGlHWydUGFzUGt3+UzzDga056sNhRQf3JYWaAC4dmwWlpDm4EFsRHM9sKKVBJQdGW5TbUUReP+0VhRHs87WQ7t8sEEb5zNQnxGDwYDVaqWhoUFPstFWeVADFN7lGhsbO1X+ULbhze12+03zZjabcbvd+ueRYIMQQgghhBCiK3vuh9384aP15FU2sq/cxrrc6g4tl1Nu85uWV6nW3xRFYc76fP7w0XqW760gp9zGv7/fyab85nV/vNp/VEGAcT19BynwTvxYfTB5pJa7QbOtsLbdxI6B8jNo0mOO/mBDZ+uhXb4bRViY+qXU1fl/cYqiUFdXR1hYmN4Up63yALW1tT7lQkNDO1X+ULbR0lVXXYXL5aKhoYG6ujrsdjsul4uamhoiIiJwuZqjd1rySSGEEEIIIYToir7bXOTzPjU6tJWSvvYHCDZsL66lweHilvfWsmS3mmjx642F+vwvNxaw5P7JbCmoYUtB4C4NJ6RF+bz3TgTZ4HCxp7Se2z9Y61OmvL6JfeU2eiS0nsugoLr1oTEz4yJanXe06Gw9tMvXVNPS0gB1BIiWamtrcblcZGZmdqg8QEVFBQCpqakAmEwmkpOTKS4uxuFw+EVwWpb3ft3WNsLCwvQWDt6CgoJ47733Ai6nsdma/1MFyvkghBBCCCGEEIfil73lPDh7M32SI7lvah96JbU/xOGvFRrsW6fpldixbRbX+He3qG5wMuOnvXqgoSWt5YP3MJZT+ycxf1uJ/t4c5NsBwDsfw46iOs58cQkOl3/X98U7y3yCDR6PQoPTrXfJ2FfWXI8bmGbVgx2hwUay4sJb/6BHCe9W+B2ph3b5bhRjx6rjnm7ZssVvnjZNKwMwevRoDAZDwPKKorBlyxbMZjPDhw/328bWrVs7tI229unAgQPU1dUxevTow9IqoaPJU4QQQgghhBCiPa/8tJeciga+31rCqc/97FMp/61EhjbXixIiQwgzN1dk3Z7WuybkeXVlOH1Asv66rD5wXgWA3kkWmlxuvthQAKhDXJ7SL9GnTIPDNw9EnFc3ilU5lT6BhpN6J+ivF+0s1V/bnW4uf20F5768lIU71EBGsMnIpSMzeOq8gTx3yRBmXDWcL+4Yx6ZHTyM6vGt1j+9IPbTLBxvGjRsHwJdffuk3T5umlQE1X8IJJ5zA5s2b2bdvn0/5bdu2sXfvXoYPH653nziUbWjBhi+//NKv385XX33lV76zvL/YtpJJCiGEEEIIIURHKYrCthZDM77zy34A9pXV88TX21iXW9XueuxONxvyqnG51bpKTaOTvMqGVnMaaHkQAJKtzfWw/8zfyYBH5/HW0v0Bl/Me9vKswSn6a7Op9Yqw0WBg4fZSfZtnDExmX4vuGC1bRYSHBH6K/870kbwzfSSpUaGEm01U2RzYD45Qsb/cxhvXjeDHeycxuW8SAHed0ot/nj+Aq7Lr6VW5mNMtexhStxjz9/fD/06EZ3vC+g9a3fcjrbP10KOuG4WiKD4nofba+8MYDAb9gw4ePJgRI0awZMkSZs6cyTXXXAPAmjVrmDFjBlarlYsuushnGzfeeCN33XUXd999Nx988AEWi4Wamhruvfdefb63yy+/nIcffpiXXnqJ888/n8GDB6MoCq+99hpr165l4sSJ9OzZUy8fHx/PeeedxxdffMEzzzzDX/7yF4xGI7t27eJf//oXJpOJa6+99pCPkfcwI9rQI0IIIYQQQgjxaxTW2P1GW9hVUo/T7eGSV1dQXt/Egu3FLLl/cqvrWLq7nPtmbaS41s65Q1K5fVJPzv/fMhocbiJDguiXYmVK/0RumtBdr9N5t1BIOzgqQ5PLzYsL9wDwxDfbuH58tl7m+63FfLu5iBX71G7rUWHBjOvRnNRxS2HgXAwADpeHr7xyOFw4PN0vwLJsTzmnebWUMJuMmIwGn1YWA1KtTOyVgMFg4Ks/jCfecnDECkWBmnz6Va2DzauhcD1UHYDgUPC4oSYf3G2MmLHwSRh6Zevzj6DO1kOPumBDU1NTwMSJ3n1C9u7dS/fu3QE18PDOO+8wceJErr32Wl577TWio6P57rvvMJlMfPjhh/rwlJpbb72VefPm8dVXX9GvXz9Gjx7NL7/8QlFRERdddJFfICAlJYUZM2Zw/fXXM2LECM444wxKS0tZuXIlSUlJvPnmm37NSF5++WXWr1/Pgw8+yKxZs8jMzGTevHk0NTXx/PPP06tXr0M+Rt7dL7yTdAghhBBCCCHEodoQYBQIh8vDvC3FlNerFeS8ykZcbg9BJv9G8ntK67jmrZVodfKthbXMWLyXBof6tL+uycWqnEpW5VTSI8HCKf3UJ/51XsNXZsSqdcHtRb7J9rVt7iur584P1+F0N1f8EyNDiIkwkxUXTk5FA2sPtN76Yl+5TW/JEBdh5sTucZzYPY7y+iZeX7JfX583g8HAxF7xhASbOKl3AuN7xpMRGw5uF+RvJD7/YFChci9U7IHG9lt/tKquCGoKICrt0NfxG+lsPfSoCzaYTCa/lgUtRUb6JgwZMGAAe/fu5d///jdff/01FRUVTJ8+nYceeojs7Gy/5YODg/nmm2+YM2cOL7zwAps2baJfv368/vrrnHnmmQH7n1xzzTWMGTOGp556itWrVxMSEsITTzzBn/70J7/9ATUR5bZt2/jf//7Hhx9+yLZt2zj33HN56KGHOOGEEzp5VHwZDAaCgoJwuVz6OKdCCCGEEEII8Wts9BoWsm9yJDuK1Qr/v+fv9CmXU9FAz0QLdqebx77ayqqcSv5x/gk43QreKRYMwNxNzSNNxEaYqTzYcmL2+gI92OCt28FRGXYV+wYbNhfUMCQjmse/3uYTaADYXVoPwNBuMeRUtD7iQ0sXjUjXgyYPTevPNSdmsa/cxoQWQ18CvD19lNpqoXw37HwbDvwCB5Z1LLAQFqO2alAUiM6A+N6Q2A+a6sDjguyToGgjlGyB9BEQFNL+Oo+AztZDj7pgQ3BwMK+//nqnl4uOjuapp57iqaee6lB5g8HABRdcwAUXXNDhbfTu3ZuZM2d2uHx4eDj33Xcf9913X4eX6SiLxUJ1dTX19fWHfd1CCCGEEEKI48/Wwhr99TlDUtkxTw0yHGhRgd9fbqNHQgRj/vGjnvvg83X53H1qb59yWhAA4OaJ3fnzaX0Y+fQPVDc4Wb5XHdWvZR6HYKPh4LK+wYZFO0qptbtYvKus1f2f0CueOevVxI+WkCBSo0PplRjJWYNSCDYZuXHmGr1suNnEzRO6+yyfERuutljQ1JXA7vmwdyGUboOGSrCV0qbIFEgaAEkDIWM0pA2DyGS/Yk0uN01ODxjAGhoMfc9se71Hic7UQ4+6YIPomMjISKqrq6mrq2u/sBBCCCGEEEIA5fVN/HfRHuIizNw8sYc+zKOiKOw42HUh3mJmfM94/sXOgOvYVVLHqOxYn8SO/VOsPskdW7psZAbBJiO9kyJZtb+SSpsDW5NL72KhqTq4zh0tWjYs3l3uk4th+rgs3l6Wo79vcrk5Z3AqDQ43RoOBswenEBnanGNAS9wIaguLh87sR5ylRQsCWwUcWAr7f4bcFWpLg7aERkH3SZA1QW2RkNAXgtVuILV2J5vyali/uortRQUYMGAwQGF1IzOuHs6sNfk8+716fCf0iue1a0YQFtz+cJJHWmfqoRJs6KKioqLIy8ujurr6SO+KEEIIIYQQogvYU1rP9HdWkVfZCMCm/BpeuWo4JqOB8nqHnhyyT3IkvRIjMRjUlv8tbSuqpcnpGyQY1zO+1eEQ+yZH0j3BAkB6dBirDk4vrG6krM43WWJFfVPAUTE25lXrr+MtIZzYPc4n2LA5v4YRWbFcNSYz4D6EBptY8ddTiAoLbh5as2wnbP9abblQthMaygMuC0BQKITFQlwP6H26GmRI7A/G5twVTS43z3+3na83FZEdH8G/Lx5MZGgQ/zd/l15maLdoEiwhlNTa9WlLdpdTUmMnKz6i9e0fJTpTD5VgQxeVkKCO51pW1nozIiGEEEIIIcTvY2NeNbe8t5ZB6VG8evXwViveR0qTy811b68iv6pRnzZ/Wwn/nLeDB8/s59NtoVdiJGFmE+cNSdO7JUzoFc+KfRU43QpzNxVRVusbJPhiQwF/Pq1vwG138+qakBrdPBjA7R+sax7F4aAKm4Pcyga/UTG8jc6Opdbum6BwzYEqRmTFBl7A1QS5K0gu2QrVuVCTp3aLqNzX6jYwGCH5BOg5BXqdBmnDwaRWnxVFCfj9hgSZuP/0vkwfl03iwVYeSdZQ/nXhIP4yexOWkCD+eeEgDAYDhdWNPstW2Jq6RLChM/VQCTZ0URJsEEIIIYQQ4uhx7n+XAVC8zU5xrZ2UKP8R9g6Fx6PQ5PI0P40/aOW+Cr7bUswN47N98wy0YntRnU+gQfPaz/s4bUASe73yK/ROUhPg/+eSwfz5tD5Yw4KxhARx7stL2Ziv5nVYlVPps55P1+Rz9xTfnA2a5Kjm7hVpMc3HZXdpvU9eB1C7eWzKb84dMSg9yuc9qK0DahrV7hZDMqK5fFQ3zh6cos50NqqtFEq2QPFm9a9wPTjbSRwZmQoxWWqOhe6T1HwLodaARdsKJBkMBj3QoLlkZAaju8cSbg4i4eBIF2X1vsGU8vqukfhfgg3HAQk2CCGEEEIIcXRomeQwoWUugEO0t6yeG99dQ3l9E0+dN5Bzh6jDIRZWN3LpaysAKK2z878rh/ssN29LEbe+vw6AM09I5r9XDGNLQXOF/eFp/XC6Ff45bwcA328t8ekW0SNBfcJuMBh8WiJM6JWgBxtaKqtrYtnBpI8tJXlVvlOiWs/rAFBa28RWry4UN4zP4pWf9hFvCSE2wky8xcxZg1JodHo4b0iqmneh6gAsexb2LFADC4qnzW0AYAyCjDHQ7yzocybEBO5+cbhkxvm2Wihv0X2kqo2WHEcTCTYcB5KT1YymhYWFR3hPhBBCCCGEOL5pORA02nCKnVFW18THq3Lpn2plct9EyuqauPqNlRTWqH377/l0I9awYE7uk8iT32zTl/t2czEfrcqlV6KF4Zkx7C+36YEGgO+2FNPk8rDZK0gwtFsMWXHherBh5f5KjF4P6/skRwbcxzsn9yQjNoy8ykbq7E4y4yJIjgrl9g/U7f37+8AJJZN9gg3+LT4SIkOY3DeRPkmRRISY6JMUyYXD0oiNMBMbYebcIenNhR02qCuEit3qcJE5SyBnKRAguYQmKkNN4pg1Xg0qxGSBJVnvFvF7UxSF8nrfYENlQ9cINnSmHirBhi5KiyhVVla2U1IIIYQQQojjV2mdnY9W5tE7ycKU/kkEH0IgoD3binyTGTpcHn2Uh4569KstfLu5GIDBGdFsL6zF4W5+Qu/2KLy8cA8n90n0G4ryr7M366+DjL5N/B86sx+hwSa2HBzW0miAfimRhJuD6JloYU9pvU/yxez4CKLDzQH3MTTYxKUju/lMa3K5iQkPpqrByeYC/1YPIUFGsr1yEWTHR/C/K4dhMEB4sIkT0qOJjTCD2wXlu8DtgPrtULAHbGVQXwaVe6GmQH3v8u8K4iOhL6QMgaT+kDxI/YuIa3uZ35mi+IdGvEf2OJp1ph4qwYYuKiJC/Q9rs9mO8J4IIYQQQghx9Hrym+18vVF9CpseE8Y700fSM9H/yf3ukjoW7ypjUp+EgPPbsqfUdxjAWrtTT3xY0+hk4Y4SRmXHkRYdOI9Dnd3JD9tK9ffelf8kawglB5Mx7i+34fYolLV4Ku7N5fGtxl4/Lhtbk0sfSrJnooVws1oNHJkVy54WOROGZES38Un9hQSZePbiweSU2wgJMtEz0UL3hAhcHgWjwaslg8cDtQWYqw9wZqgdUNQ8ChsOQPEm2L0A7NVtbap10Zkw7GoYfAVEpR3aOn5HRqOBR87qzyNfNA+t2TJIdLTqTD1Ugg1dlPYlNzS0k+hECCGEEEKI49j63Cr9dX5VI/fN2sSc28fqSf7qm1w8NGczX25QAxLvrzjAT38+uVPb0Crymnq7i3hLCHtK65nyn8UA9Eq0sOCekwIu/9POMp9WDN7uPbUPH67KZUNeNZU2B8v3VujDRfZLsXL3lF7kVzXy8qI9VNocRIYGUec1UkNpXZMepAAYntk8YsOIzBg+WpXrs70T0qI69dkBpmSZIa5SbZVQuR7WbAWTWe2mUL5bTdhYuh2cv+JBaXgcRCRAeDxYEiC2h9qKIWMURHeDo2z0j/ZcPSaT0wYk8caS/RTX2FsdsvNo05l6qAQbuiirVc2M2pHxTYUQQgghhDge2Z1uCloMMbghr5rvthRz5gnq6AVvL92vBxpA7QLRWX7BhiYXiqJww7ur9Wm5la1XzhbtaG7VcPHwdGatzdffn9w3kR93lOjvZ63N01/fPDGbqQPUPvQXDk9nS0ENQ7tF8+z3O3l7WY6+3Z3Fzd08Bqc3BxPG9vTtXpAVF87JfRL8d9DZCCVb1REeCjdAbQG4ndBQATX50HgYunaHWKHHyWpQITQa4nuBNRXCYiE2G0I619qkK0iMDOXBM/sd6d3olM7UQyXY0EVFRakXidra2nZKCiGEEEIIcXzaW1aPNlCENTSI2oNP/L/aUKgHG5wtuh0M6Rbtt55FO0r5elMhZw9O5eQ+iT7zHC4POeW+T+wdbg8Gg8Ent4JHCZzAUFEUFu9SM/uHm01cNqqbT7AhITJEHXHhIC0wYjDAxF7NgYGosGDG9YwHINNrKMycchv7vPavf2rzcI4pUWF8duuJWMOC9dEe8HjU4SIP/KImXyzeAtUHOjbCQ1tistSWCHE9wWxRP0BQiJqoMbEvJA6AIDNuj0Jto5OC6kZ6JVoICTa1u2rx++lMPVSCDV1UWJja96mxsZ0EKUIIIYQQQhynthc1tzi4dVIP/jN/Fy6PwgGvVgZp0b5DMZ7YI97nvcej8KdPNlDT6GT2ugJO7Z/Efy4ZTGRoMAC5lTa/PAmNDnUYybgIMxUHhzR0ugMHG95cul8vM6xbDEU1vvf3Ho9CfIR/wsYhGdE+QQhvWQcTMsaEB9PodNM7KZJXrhrG0IwYkqNC1QyFtjKoLWREwwEoKlBbKRSuh4I1YA88vKUfg0ltfRCTpY74EBSidnVIGawGExw2tYVCXC8IsQDQ5HRTYXOgHHydEhVGmNmE2+PhsS+3sKeknktHZjBtUMpvksxT/DqdqYdKsKGLiomJAaCqqgqXy0VQkHyVQgghhBBCeNvtlbhxQGoUsRFmSuuaqLI1DzOY2iJp46isWJ/3pXVN1DQ2jxSwYFsJn6zOI7eyga82Fuq5ELxpIwskR4XqgQRQu3WEej2p/2VPOc98t0N/f+OEbBZsa+4yAbCvvJ74SP+gwpkDUwJ/aGB0dhxbHz+NiJCDdQSHDQrWwqbVaouFvFXQ1MEW0sERasAgaSAkn6D+xfeGILPaQsEYuOVBaZ2dsrom4iNCSAppDuhc8upyNnoNw/nRTWM4sUccJqORJ88d2LF9EkdMZ+qhUkPtouLj1Yirx+Ohrq5O/9KFEEIIIYQQKu/uDd3jI/RgQ6XNgd3p5oUfd1Pb6DvkYO8kCyW1djbkVTO5byKFNf5PcL/eWOhTYW6pwtZEeX0TWwt9K/T5VY1kxYWzan8lP2wv5d3lOXqw4taTejCpTyLPLdjls8z63GqSrb6tL4JNBi4c1sqoC047YXm/wN6FULlfza9QvBk8rsDlW4pIVJMuZo6DrHGQdAIYO9/CIDEylMTIUL/pegDkoLZG1hBHn87UQyXY0EUFBwcTFBSEy+XCZrNJsEEIIYQQQogW9h8MNphNRlKjw0iOCmVHcR0Ot4e+j8wLuIzbozD67z8CcN3YLAZn+I/O0FagAaCmwcn3W4v9pu8rq+fB2ZtZleObUHFCr3jundobgDE94nzWv7fMxpknJJMYGcK4nvGM7h7LSb0TiNW6UDRWQ9FGtQtE3krY95M6pGRbLElqC4WodPUvOhPCYyEmG2K7/6YjOzx78WBueGe1nlQzMUCrDXH06kw9VIINXZTBYCAqKoqKigpqampIT08/0rskhBBCCCHEUcPl9pBTrla6M+PCMRkNdPNKnNian3eX6a/f+SWHuyb37PS2qxudfL4u32/6yv2VfoGGy0d148lzBxB0MD/BA6f3ZWBqFP+ct4OUqFCuHN2NRGsIqx6aoiZvLN0KO7+H/DVq14iK3e3vUFxPtaVCtzGQPlJ9f4SGikyLDmPuXROYv7UYo9HA6OzY9hcSR43O1EMl2NCFeX/JQgghhBBCHO9K6+zsKa0nPTocl8eDw62OoNAzUU1OmBHTfrBhW8uuD15DZ47KjmXV/uZgQXpMGPlV/t0s3ly6X38dbjbRcDBh5Ip9Ffr0yJAg5t41gW5xvvtkMBg4e3AqZw9OVSfUl8GWL2DPD7B3UfvDTEYkQK+p0HOKGliwJEGQGZfbQ4PDjTUsuO3lfwcmo4EzTmg954Q4unW0HirBhi4sPFy9MDU0tNNMSgghhBBCiGNcWV0TU5/7WU/O6C0zTh2dIdHafpP91TlVPu9nryvQX0/tn+QTbJjcN5GZyw+0ub5XrhrOdW+vQlHQczgEmwz85Yw+foEGQB0porYAdn4HW+dA7vLWh500mdXuEKnDIHWo+pfQF4xGqmwOPlqVS2H1Tg5UNtDodPHe9WPa/fxCtKej9VAJNnRhEmwQQgghhBBHSn2Ti/BgE0bj79McX1EUcioaSI8JCzgk4oJtJQEDDQDmILV8Qov8AGaTkZeuGMqu4jr+72BixsW7yvyWBwgyGjixR5zPtEl9Ejh9YDJXvL7Sr7zBAH86pTcn9U6gd1IkEeYg+qdaOW1AEqOyYwkJMoHLAWU7oGQLlGyF4k3qvw0VfusDICQKsidA5ljIGK0GGoICB1DCzCaW76ugptHJdWOzOHdIGqbf6bsSxzYJNhwHYmPV/k0VFa1cjIQQQgghhPgNvLV0P09/u51RWbF8dPNv/7Tc41G4+NXlrD1QxflD03ju0iF+ZZZ45VpIjQqlsMauv39jyT7uObW33sJBc8nIdE4bkIypA/kLws0mClp0mRjWLYbocDObH5vKsj3lmIOMrM+tpn+KlbE944gKMwMw967xBBmN4HZCzhKYP0/Nt1C0ETyBAyS6uJ7Q72y1a0T6KDB1rAoXGmzivRtGd6isEJ3R0XqoBBu6MC3zZ3V19ZHdESGEEEIIcdzYmFfNE99sA2D5vgrW5FTy1cZCLh2ZwYBU/5EbANYeqGLxrjKuHN2NJKv/cIjteeeXHNYeULs3zFlfwM0Tu/POshzOHZJKeEgQVQ0Ovtuijv4QFRbMkr9M5qo3VrL8YI6EBoebH7aVMLlvIvEWM+X1DsKCTdx6Ug8AeiVZAm43NsJMpc0BQLwlhB+2l/jMDzObAIgMDeb0gWoOgsl9k5oLuJpg308E7fwO8lZBxR5wtzPUY0SC2mIhbTj0Pw+SBhyxZI5CBNLReqgEG7qwsLAwABob/ZPSCCGEEEII0RaX28O8rcWkRIUxPLPjw6jvKPZNoPjHjzdQUN3Ikt3lLLz3JAwtKsZ2p5sb3l1NdYOTrQU1vHndyE7v6/srffMinPHCEgA+WZPnVzY7PgKT0cDgjGg92AAwf1sxU/on8fylQ5mzvoDp47JIP5gwMj0mnNBgI3Znc26EU/sn8Y8LTuDRr7aycHspV4zuxglpUXy6pnmUicJqO9nxvq0lACjeAsv/CzvmQlMbSfTieqr5FpIHQtJANchgSezQMRHiSOloPVSCDV2YxaJGYOvr64/wngghhBBCiK7mw1W5/O3LrQCcOySVx88ZQHS4ud3lslp0RSg4OFrD/nIb24pq/Vo3bC6o0XMp/LijlHs+2cAlIzMYmRXboRwCHo9Cnd3Voc8EsCGvGofLw31Te9MtNpyZy3NwuDycP1Qdom98r3jG94r3WcZkNNArMZLNBc2BgVP6JhJvCeG/VwzD41H03BTv3ziK1furOLF7HFlagsf6MtjwAez4BuqKocY/CIIxCGJ7QMog6HsWdD8Jwjoe5BHiaNHReqgEG7qwuDg1QU15efkR3hMhhBBCCNHVbMxrrlh/uaGQ6gYn714/qt3lahpbzzGw7kCVX7DBe/QGgNnrC5i9voDo8GDOG5LGw9P6ERQg4aNmxb4Kyura6XrQwqy1eVw5OpMrRnfjitHdOrTMJSMz2FxQQ7fYcB6e1o+pA5L1ed5JMMf3TGB8uhkK1sGiX2DfT1CwJvCIESFR0Od06H8udJ8EZjVQsyGvmoFmq1TGRJfU0XqonN9dWEJCAgBlZYEz5gohhBBCCNGaohrfJtDrcqtaKelrS2Ftq/M25tdwdYtpLYMNmuoGJ+/8ksPUAUmM7aG2NHC4PLzzy34qbU7+NKUXIUFGnvthV7v7FBMeTFiwSU8KaQnpfDXn6jGZnDs4FUtIkO8IG7YK2LdIHYKybCfUl0D5bkAJvKKIBLCmwpArYejVYFZbP7y6eC8/7ihld0kdRoOBtY+c2ul9FOJo0NF6qAQburDIyEhAulEIIYQQQgh/JbV21uRUMaF3PNbQYL/5eVW+w9bV2V00Otx60sPWbC9qPdiwpcA3P4HL7WHdwcSO8RYzS+6fzPxtxfzx4w16GadbrbTXNDgZ/MR8fXp2fDjxlhBW56jLd0+I4Js/jMflUVi6u5zbP1inlx2VHcurV49gf7mN6gYHQ7sdWvcEa1gwuF2QsxJ2fgt7F0Hp1vYXTOgLfc5QgwtxPQIWmbu5iE356vHpFht+SPsnxNGgo/VQCTZ0YaGhaiZfu93eTkkhhBBCCHE8URSF0X//EYCUqFA+veVEMlpUcAN1TahscJBmDmt1vS63h/W51a3O31VS5xOw2FxQQ12Tmm/hxB7xhJlNnDskjUqbg8e/Vke0OFBhAxJ4b0WOz7rCzUE8PXe7/v7eU/sQblarLyOzYn3K9kxU+5CryRoDJGxsi6MBds2D7V+ro0VU5UBT6wEVgsIgvidkjIGMUZA1Xm3J0I4Lh6XrwYanzx/YuX0U4ijS0XqoBBu6MKvVCsjQl0IIIYQQx6M9pfU8NGczwzNjuP/0vj7zyuqbAwlFNXY+Xp3Ln09rLlPT6PQZeUFTZXOQFh042LD2QBXXvbVKDx5oeidZ6JUUydxNRXgU2FZUq49uoQ1XCTAyq7m1wZCMaP211hoizOxbNbnn0w16q4cRmTGceUJzDoWEyBCfspYQ/5YbbXI71VwLmz9Tkzo6WntCa4CUwZA9Qc25kDYCwqJbKdu2K0d3w2Q0kBEbzoReCYe0DiGOBh2th0qwoQvTvuS6urojvCdCCCGEEOL3NuU/iwFYub+Sq0/MJCWqOUiQX+Wbj0Gr3Nqdbm6auYYluwMndiura2LRzlIyY8PpnmDxmffP73b4BBrenj6S1KgwusWG8/m6fOZuKgLgwld+YcZVwzhtQDJL9zRvZ3R2nP66T3IkBgMoCuwoVu9ly+t9W1pogYa4CDP/vGiQ35Ca3naXduB+2F4D62bCru+haGPg1gvGIIhIhG6joc+Z0HMKhMf6lzsEQSYjV43JPCzrEuJI6mg9VIINXZh0oxBCCCGEEABBRt/RHPIqffMxaCNIvPtLjl+gIdxsosHhBmD6O6sBMAcZWffIqXqiRUVR2OaVq+GWk7ozqXeCHgAY1iJHwq3vr2NIRjQb8qoBSIwMoXdSc/Ai3BxE9/gI9pbZ2FZYyx8+Ws/8rcU+64gwmxiVHcuDZ/ajR4vAB0D/FKu+Twt3lAY+MPZaOPCL2kVi25fgCFA5ComC/mfDCRdD1gQwtp2zQojjnXSjOA6EhanRawk2CCGEEEJ0HR6Pwr5yG9nxEZiMrT+t7wxbk8una0HLYMOS3WWM7RHHK4v3+i3bP8XKmgO+I1E4XB6KqhvplaQmgiuqsVN/sFXD5L6J/PWMfj7leyX5BwO0QAPA8MwYv5YJI7Ni2Vtmw+VR+HpjoT592qAU/nRKL7onWNo8PnPuGEtto4vo8GCCtaEz68sg9xfIXQEHlkHx5sBDUkamQOY4GHA+9DoVgkL8ywghAupoPVSCDV2YtGwQQgghhOha6uxOJv5rEVUNTq4c3Y2nzz/hkNajtVTQFNXYyYpvToyYU+EbbPh5Vzmx4fuobvBdDqBvSqRfsAF88yLsLWvOaaAlY/TWsttGS0O7RftNO2dwKh+vztPfGw1qAOLv559AVFgbORg8bshfTciBZSQ01YO9Ghoq1cBCpX8wRRccAYMuhhPvhPhebe6vEKJ10rLhOBAcrF6EnU7/Hw0hhBBCCHH0uXnmWqoOVvi1XAWHYk+LHAUVNt98B/vLbT7vcysbeHHhnoDrig03B5zuXeHf6bWvPQN0aWjZBaKlMd3j/KaN7RnPj/dMxOlWSLKGYg0LwtSiOwjORijeAkUboGAtlG6Hyn1tjxahM0Bif8gaB91Phh6TITi0A8sJIdrS0XqoBBu6MO1L9ng8eDwejC0vzkIIIYQQ4qiyfF+F/npAqlV//eP2Ev49fxfdEyJ4+fKhKAoY2+hC0DJQUe41jKWiKOwpbW10Bbj2xEzeXX5Af7/h4HCMLXl3e/AONvRJjvQruzrHv2WEJiY8mAGpUQHn9UiMBLcL6gqh9ACU7VD/SrapQ1DWFwfuBhGIKUQdOaLbGMgcq/4bFtP+ckKITuloPVSCDV1YUFDz1+dyuTCbA0elhRBCCCHEkVdr930KeMtJPQD4fG0+987aCMD2olryKhvYWVzHvy8ezNmDUwOua1uh75P9Sq/uERU2h97NIiY8WG9JARAbYebOyb2Y0j+Jq99cBcCp/ZP4eVeZ3zYURdEDDlpww2AInJ9hWGY0P2wvAcBkNBATHkxadBjdEyycNiDZN/dCU706GsS+n2D/z1C4HtxNfusMyGAEazqkDoFeUyEqXR2KMjQarGkQJPfDQvzWOloPlWBDF+YdQXK73UdwT4QQQgghRHtmrcn3eW93qvdvX2wo8Jm+6WBLgz98tJ7qRichQUYm9Ir3GdqyZcuFMq+WDXu95p09OJXiGjuLdpZy1qBU/jSlFwmRISREJvDjvSdR2+gkPSacR77Y4re/H63K44rR3XC6PewsUYMN2XERhJv9qxC3ndSDK0dnEmQ0EBHiNd/jgeoDsPFjyF0OeauhdBugtHWoVBEJagAhaQCkDIG0YZB8giRzFOII62g9VIINXZh30zZF6cAFWwghhBBC/G6W7Sln4Y5SLh6RTt9kKx+sOOAzv9LmoEcC9E6K9BuOUuMdBDghLYrHzx3A0Ixov5wM5fXNwYbdXsGGXokWnjh3IG6P4jeygzacZMsWF5rHvt6KJTSI4ppGHC61K0N/r64fOlsFhryVRFXug9rC5oSNtflQsRecDf7LeIvJVgMK0d3UxI0J/SChD4THtr2cEOKI6Gg9VIINXZjkaBBCCCGEOHJcbg+frMkj2RrKKf2S9Ol2p5u/f7udmQfzIny6Oo/nLh3CvhYBgop6BwC9A3RLCGRzQQ0X/O8XUqJCKa3z7XawYFsJtXYn1tBg1nqNLNEzUc2v0NYQkqFBpoDTHS4Pd320Xn9vNMCtB7t+AGArh1Wvw7IXwNX2aBQ6g0kNLKQOgW4nQvdJYA3cVUQIcXTqaD1Ugg1CCCGEEEIcglveW8uPO0oBmH37WFKjwkiIDOGat1axan+lXq6uycWNM9f4LV97MK9CYmTnRkgoqgk83Nzgx+fj/ZDRHGQM3BKhBXOQkSCjAZdHXTjIaGBQehRNLg/pMWH0T7EytFsMo7JjCQ02qXkWfv435CxpO3mjwQQxmRDfRw0uZI6FtOFgjmh9GSHEMUOCDV2YdJ0QQgghhDh0324u4qNVuZw3JI0LhqX5NA1uj9Pt0QMNABf87xcAws0mGhxqH2aT0UBmbLhfiwZNfZMLgJLatseqj4swU2FztLtPLW8N/3hKL5/hK9syrmc8A1KtjOkex4isGN+8DPWlULAGfloBB5ZB/mrfhY1BMORKNZgQ3Q3CYtWkjREJYAzcakII0XV1tB4qwYYuzPtL7syPoxBCCCHEscTjUVi5v5K06DC6xYV3aBm70839n22ivsnFkt3lfLelmBcuG+Kb3LANbk/gm20t0ADw1zP6MjgjmotnLA9Ytvpgy4aWw1i2FBUWzJPnDeT2D9b5zXvs7P5EhQez7kA1m/Kr2V5Uh8PtYUz3WG6Z2L1DnwXg3etHgb0GclfAT0vU0SIaq6GuCGz+I1UAEJMF/c+DYddAXI+ARVxuD0Em6forxLGko/VQCTZ0YR5Pc7M1yd8ghBBCiOPVG0v38fdvd2A0wHlD0rhnam/SY9oOOizdXa63LAD4YXsJH6/O44bx2R3aZmhw+0/szx6c2mo+BICqg60VdpW0HWywO92ceUIKH9w4mu+3Fuu5IADK6x1cNy6b84emA9DkclNS00RKdGj7lXx7Dax+Aw78AtV5ULEHlA6McBbfG8b9CQZf1m7LBQk0CHHs6Wg9VIINXZjT2Zw5ODi4Y03khBBCCCGONdpIDh4FZq8vYMW+Cn6+/+Q2K7pzNxf5TcurbGfUBC9Odxu5Cg6KCgv2C0r0TY7UWzJUNThQFIXtRbV+y0aGBFF3MBjSeHCIzHE94xnXM94n2PDjjlLuO62P/j4kyNR26w6XQ821sP1r2DpbDTi0xhgE4XHqyBDJgyBjFGSMgcik1pcRQhzzOloPlWBDF+ZwqNFwk8kkLRuEEEIIcdzKqfDNiVBYY6ew2t5qpdvudDN/a7Hf9OqG9vMiaIpbSdLobfGuMk4bkOwzbXzPeD3YUF7fxKb8Gqoamm/cx/WM49oTs5izvoDvtqj7qA07qTljYLI+r9LmOypFQG4XHFgKW+fA1i/UoSlbCgqF2O6QNQGyxqsjRUTEg3TVFUK00NF6qAQbujC7Xf2RCw3tXAZjIYQQQohjRZPLTUGV/7CLeVUNrQYblu+twHYwt8LE3gn8vEvNSaB1q9hRXMuc9QWc1CuBsT3jA64jP8A2W/pmU5FfsCEzLlxPIlla18T7K5pbKTxzwQlcNqobAF9vam55obVs0Dx36RCsoVv5fF0+U/q10spAUaBgHWyeBVs+C5x3ISgUBl4I4++GuJ5gMNDkclPb6CLBEtLu5xNCHJ86Wg+VYEMXVl9fD4DF0rGxmYUQQgghjjUHKhoIlKsxv6r1LhELtpfor88dnKoHG+rsLm59by3zDrZ6+GBFLhsfnYrJ6P90v2VrCoC06DAsIUHsPJiDIVBLiURrKImRIeRUNLCvzMa+MnU9kaFBnDMkVS/n3WLBo6gJKbX9CA028c+LBvHkeQMxB7V4quhshG1fwtLnoGyH/4cPDoc+Z0K/s6HXqfowlPd/ton95fVsLqjh89vGkhApwQYhRGAdrYdKsKELk5YNQgghhDjeaZV1gMHpUWzMV3MQFFS33s1hTU4lAGaTkdMHJvOXzzfhOjiihbf6JlfAQIO63Xq/afGRIcy+bSyfrslj5b4KbpzQnUaHb6uEKpuDxMhQcip8gyEXDkv3GW6yZWuNvMoGsuIjfKbpgQZFgX2LYOWrsG8xuFq0ujCZofdpMOB86HUahPhXED5dk6e/7pkoD7KEEK2Tlg3HgYYG9UcqPLxjQzwJIYQQQhxr9pc3BxvG94rXgw35B5M95lU2kBwVSrBXssiKerXFQaI1hIiQIOIsZkpqA+c+WJ1Tycis2Da3q6lrdGIyGrh8VDcuP9gdYkexb/LHXSX19Ei0sCqnObCRGRfOLSf5DlNZZ28eKaNHggVHy4SUiqIOU7l5lhpoqNznv/MZo2HIldD/HAiLCfj5QB061FtIGyNoCCFER+uhEmzowmpr1R8vq9V6hPdECCGEEOLIOODVnWFcz3j+u2gvAAXVjTw4ZzMfrsxlfM943rthFAaDAbdHoepg94aYcDMAEeYgIHCw4ZWf9jLyOv9gw74AwYaCav88DqnRYT7vaxqd/OWMPlhCTMREmDmpdwL9kq0YW7SguOuUnpTVO5h2Qgr9Uqxq94icZVC0AQo3qP+W7/LfYUsy9JoCg6+ArHEBP1NLZfW+n11RFAySGFII0YqO1kMl2NCF1dSokfuoqKgjvCdCCCGEEEdGrtdwlf1TrESYTdgcblbur9S7RSzdU86+chs9EizUNDr1HA9xFjXYEGTyrViPyIyhqMZOQXUjC3eUcqDCRmZccxeG+iZXwJYNTS7/4TCtocH8dN8kbn1/LXvL6jm5bwKJkaE8NK1/m5/r2rHZ6rCUu76HRZ/B3kXgbmXkCWOQOiTlqJvUXAzGzrVMaPlZPAqYJNYghGhFR+uhEmzowrTEHJGRkUd4T4QQQgghfCmKwms/76OktombJmaTEhXW/kJAWV0TZXVN9E/tWMtNLdhgDQ0iOtxMfGQItgr/5JC7S+rpkWDRWzVAc8sGa6jvOPFT+ifhURT+NW8nAP/4dgdTBySxu7Seqf2TcLg8KAcDFlP6JfLD9lIAhnWLDriPWfERfPfHCdQ3uYgMbX1MekAdpnLrbFg3E3KXg8cVuJzBBGnDYcT10O8sCDn0+0HvLibgm4xSCCFa6mg9VIINXZjNpkahIyIi2ikphBBCCPH7WnOgin98p46GMGtNHq9ePbzVYSShOTjxf/N34XB7+O8Vw5g2KKXNbdQ0OPUhKDNi1b7DBwIEGgA950F1g1OfFhWmVvy1Fg6ayX0TiY0w8/yC3TjcHuZtLdZHqHhzyX6mj8vSy07pl8SFw9J5f+UBbpnYo9V9NRgMrQcaPB7YORd2fAv7foK6Qv8ykSnQ8xRIGwFpwyChLwQdnhEjhmZEkxYdRkF1I9HhwRJoEEK0qaP1UAk2dGF1deqwSjL0pRBCCCGONhtyq/XXdU0u7v98E4vum+T3FF3z/ooDenACYGdxbZvBhke/3MK7yw/o77cW1lLT6Gy1vHKwKUKtV5nocLXyb2yRn6B3kvq07qxBKcxeX+Azz+H2sK2oOenj4Ixo+qVYOeOEtgMjAdkqYNsXsOp1KNvuPz8mSx09ov850G0sGAMfu1/LaDTw1Z3jeHf5AU7qHS/BBiFEmzpaD5VgQxdWWan2Q4yJaT27sBBCCCHEkdAygWJ+VSOz1+Vz6chuAcvvLKnzeZ8eE87fv93O7HUFXDG6G/ec2lufV17fxMwVB1qugvtmbdSf0ANcPSaT9w6Wa3S42VNaxw3vrtbLa90n8r2GmeyR0Pyk7qFp/fAoCkv3lFN+cASL9JgwluwuByDcbNIDEx1WV6K2Ytj+Dexf7N9NwmSG7ifDuLsgcxz8Toka4ywhPsdYCCFa09F6qAQbujAtMYcEG4QQQghxtJi9Lp8vNxSydE+537z//bSXC4elExSgdUN6jO8Qao9+tZVGpxuAD1ce4Ibx2ZTU2umVaGHhjlI9Z4K3BoeL2beP5aE5m+meYKFXYvNTty82FPDA7M0+5SND1Vvh0wYksblAva+6aHiGPj/OEsLzlw3F41GY9O+fyK1s8AlMDEqP6lgrgMZqtQXDpllwYBkQYOfTR8HE+yD7JAhue+x6IYQ4kjpaD5VgQxemjW8aFtaxhEtCCCGEEL8lp9vDPZ9u9JmWERtGZmwES/eUc6CigYU7Spk6INlv2ex4376/WqABwO70cNpzP1Nca+dfFw1i4cGEjACf3nIiDpeH4lo7k/okEG8J4Y1rR6rzVufp5Vbsq/TbZkSIeit83bhsthTUEhJs5Ibx2X7ljEYDFw1P5z8LfIeavGREhl/Z5p2uhZ3fqcke9y4Et8O/TFQGDDgfTrgYkk/43VoxCCHEr9HReqgEG7ow6UYhhBBCiKOJ90gPmj5JVq4c3U1v6fDZ2nxO7Z+EoUXFukdC631/HS4PxU12AO7/bJPeIiE6PJjhmTGHnGNACzZYQoKYcfXwNsteNjKDN5fup6bRyUm9E3jwjH70SWnRhaImXx2qcud3aheJQAGGuJ7Q/1zoexakDpUAgxCiy5FuFMcB7UuOi4s7wnsihBBCCAH1dv9hGvsmRzKhVzwx4cFUNTiZv62Ek//9Ey9cNpTBGdF6OefB0SICcbSYV3dwO+N7tp3MsL16fFiwqe0CXhKtoax68BQUIFRbzu2EvFWwZwHsmg+lWwMvHJkC/c+DwZdCyhAJMAghurSO1kMl2NCFaX1loqKijvCeCCGEEEKA0+2fi6B/qpUgk5GT+yTqIzvkVDRwwSu/cM+pvbnj5J4A7Cz2TRBpMBAwL4O3Kf2S2pzv8VpB3+RIdrTYRrCpE5X+hkpCKvZCxR4o2wElWyF3BTjqApePTIV+Z6lBhm4n/mYjSQghxO+to/VQCTZ0UYqiUFJSAkBCQsIR3hshhBBCHGuW7Snn0zV5rMmposHh4vnLhnJSb997jkU7S/nfoj2Yg4z894ph1Np9h55Mjwlj4sFlym2+XQrcHoVnv9/J3E1F9EuxYg3zvS1tL9BgMKCvuzUhQc0tF7rFhvsEGwwGiAoLDrygokDZTsj9BQ78AvuXQH1x2zuEAdKGqUNV9p4qLRiEEMekztRDJdjQRdntdux2te+iBBuEEEIIcahcbg87iusIN5vIiovAaDRQVNPIdW+v8mmpcO+nG1l430n6cJH3f7aRT9fk6/NX7q8k3Nxcub/2xEz+dvYAvZtDXYtAhGZbUS3bimo7vd/9kq3ERpjbLGMOMmINDSLMbGJUdiw9Ey30SLCQHhNGv1Sr/lmoL4PC9VCwVv0rXAcNFe3vRHg89DgZek6BHqeARe7JhBDHts7UQyXY0EXV19frr8PDw9soKYQQQggBczcVcaDSxpWjM32e6D87fyevLt4HQITZxIXD00mJCvPrElFe38Snq/O4cUJ36uxOn0ADQHRYMMW1dv19Rmy4Tz6Fi4dnsD63+rB9ntTo9oeHnNg7gU2PndY8obEaSrdDbQEs3QJFG9UWDLUFba8oOEJttRDfC2J7QEIf9S8qQ1ovCCGOK52ph0qwoYvSknJYrVZMpo4nNxJCCCFE1+V0e/hoVS4r91Vy60k9OCG9Y3mbthTUcMeH6wD4YEUu/7tyGIMzolEUhTnrmivaNoebmcsP+Cz7ypXDuO0Dddl3fsnhurFZRJiDCAky0uRqTtzYN8XKlsLmFgrxlhCf9VwxuhthZiNPfL2NqobArRw0V4/J5LyhqaRFh3PqfxZjc7h48Mx+vPDjbj055M6SVnIlgNoNoq4Yy96FsHs+OGzQVAf5q0Fxt76cJiwWMkZB5lg130LKEAhquxWFEEIcDzpTDz1mgg0ul4tly5axefNmDAYDgwYN4sQTTyQoqPWPWF9fz1dffUVlZSW9evVi6tSpfsMweVMUhcWLF7NlyxasVivnnHMO0dHRbe5Xbm4u8+fPx+l0MnbsWAYPHnyoH9FHdXU1IMNeCiGEEMeLSpuDM174mZLaJgAaHC7enj6qQ8vO39qcb6CgupFb3lvL0r+cTEldE6V1Ta0u1zc5kjNOSOGk3gks3lVGflUj328tYdqgFLrFhrO7VH3ClR4TRlRYMBX1zeuKs/hXzs8fms45g9PYWVzHmS8uCbjN68dl87ez++vvl/5lMg1OFylRYYSZTfzty61M6pPA3VN6Ny+kKJCzFLZ8BsWb1dYKjvoAaw8gNAqSBqrDUKYOhfQREJ0pLRaEECKAztRDj4lgw9dff80NN9xAWVmZz/SkpCTeeecdTj/9dL9l3nzzTR588EFKS0v1acOGDWPGjBmMHDnSr/y2bdu45ZZbWLp0qT4tOjqaRx55hHvuucevvNPp5M9//jOvvPIKDkdzQqQLL7yQV1555VfnWdCar1gsrY9JLYQQQohjx7wtxXqgAaB7Quv3AJ+uyeO5Bbs4d0gafz6tD4t3+d4jFdfa2ZhfQ0F1oz7trlN6YQBe+HG3Pu20AckA3DghW1/HlxsKmDYoxacurnXL8G6xEBMeuCWAyWggLSas1X2/YFiaz/uo8GCiUNd/xahunDckjQizCUq3waL/qTkWynZCTW6r69TF9YTskyAmC+J6qC0WrKkSWBBCiA7qTD20ywcbSkpKuPjii3G73fznP//hnHPOUZsEzpnDAw88wIUXXkheXh6xsbH6MnPnzuXGG28kIyODr7/+mqFDh/LRRx/x8MMPc8YZZ7Bt2zYSExP18jabjTPOOIP8/HweeeQRbr75Znbt2sXtt9/OvffeS2xsLNddd53Pfv31r3/lhRdeYMKECbzwwgtYrVaefPJJ3n33XSoqKli4cGGbrSjaow03YrVaD3kdQgghhOg6+iRH+ry/9sSsVsv+3/ydlNQ2MWPxXgqrG9lUUONXZnVOJaVewYuh3aIZ3zPeJ9iwOkdtLju2RzwJkSGU1TXx084yau1OXJ7mnA5aboYyr1YSLbtReLOG+t6CTugVT4PDzd1TejMwrUXXkKY6qM6DhgoMjZVEVB2ATZ9AyZZW1090JsT3hsR+0O9sNcgAEB5Lk8tNQVUjeZUNjA6PI1QCDUII0WGdqYd2+WDDBx98QFNTE3feeSd33323Pv3Pf/4ze/fu5dVXX+Wjjz7ijjvu0Oc98sgjAHz11VcMGTIEgPvuuw+3280DDzzACy+8wNNPP62Xf+ONN8jNzeVPf/oTTzzxBADp6eksWLCA7t2788gjj3DttdfqwYPS0lJefPFFUlNTmTdvnp444+2336aoqIj58+ezcOFCTjnllEP+3MXFanPIpKS2x5cWQgghxLEhr7LB573D7QlYrqTW7tMC4quNhfrryX0TWbhDbdW5JqfSpyXC4PRogk1GrhubxTu/5KjbOJiTwWQ0MO2EFN75JQeH28NPO8twBwo2HOxGYTBAfIBuFBqDwcDkvolM6ZfE2B5xdIsLx2gwgNsJJVvVJI57foC9C6G+pN1joydwHH4d9D4dQtQnbh5F4cftJWzbWU6Dw82ukr0s31eO3al+rq2Pn9bGSoUQQrTUmXpolw821NWpyYH69evnN0+bppUBqKioYP369QwYMEAPNGiuuOIKHnjgAX744QefYMMPP/wAwFVXXeVTPiMjg4kTJ7Jw4UJ27txJ3759Afj5559xOp1ceOGFPhk6DQYDV155JfPnz+eHH35oNdjw0EMPARAWFobVaiU0NJTg4GAiIiLo1q0bY8aM0RNzxMfHt3+QhBBCCNFlrNhXQVldE6cPTCbYZNSn/9yiK8SsNXn89Uz/+5+thf6tGDSnD0hmQ141lTYHK/ZV6gGLbrHh+jCSj50zgGGZMczfWsx1Y7P0Zaf2T9KDEHM3FaJ4DVahtQ3QcjZEhwUT5LXvgbx13Ui1xcLWN9XRIKpzYf8ScLSR+NFb2ggYdCn0Ob3VUSHqGl3cNHNtq6swB7W9j0IIIXx1ph7a5YMN48aNA2Dx4sXcfvvtPvN++uknnzIAv/zyCwAnn3yy37oyMjLo2bMn69ato6GhgfDwcDweD7/88gtWq5Vhw4b5LXPyySezcOFCli1bpgcbli1b1uo2tGlamUCeeeYZPJ7ATytOO+005s2bR22tmu05KqpjWaiFEEIIcXTYnF/DjJ/3cuGwNCb39X0ytLesniteX4FHgeGZMfzvymEkWdUhHr3zKwB8vbGQB87o69ctc1N+c7AhKiyYmka19cLANCuT+iTw444Svt9aQn2TSy/XchjJcwancs7gVJ9po7vHEW8xU17vYNHOMkK9KuoNDjd2p5uSg0NfavvsQxsNYud3ULAOmmqhYm/bo0OYIyFlkNotIiIewmLAkghpw9UuEu2whLZ9q+t0e3wCOkIIIdrWmXpolw82nHLKKdx+++3873//w2w2++Rs+OKLL7j77ruZMGGCXn7LFrV/n3dOBm9JSUns2bOHnTt3MnToUIqLi6msrKRHjx4BcyxozUc2b97coW1o07zLe1MUpdVAA0BkpNpfU/uStfdCCCGEOHp4DnYxMBp97x3cHoWzX1aTTa/eX8k/LzLQ5PSQHhNGRkw4y/dWoPVOWHugigc+36SPONGyG0VhjZ21B6oYkRVLcY1ayU+OCmVjXrVe5us7x2MwgDU0mKhwNcnimO5xfL/Vt2uC9xCWrTEZDZw1KFXtSuHy6F0sQB2G8um527loeDojMmOZ0v9gEKXqAGyeBVu/OJhjQQm4bl1YLHQ/CRIHQOoQyJ4IQa3nfujIPsdGmKm0OQLO31dm888RIYQQolWdqYd2+WCDwWDgP//5D2azmeeff573339fn3fffff5dIeA5i4V3gkjvWnTtSybnS3f3jIhISFERET4lPfmdrc99rM2xEhVVRUgLRuEEEKI31uTy42iQGhw4PHFy+ubuO7tVewrs/H8pUOYenBEB4D95c2//6V1TUx/e3Wb29pVopa3O90UHgwoePtyQyEF1Y388eMNmIOMfHXnODYfTAYZHR5MRmyY38OS4Zn+w5WdOTClzf3QnD80jY9X55IRE86EXvGMyo4jJSqUrPgIdUQKt1MNKqz7HHbOg9xfWl9ZiBUiEmDQJdBjsvo6uhsY2x63vbOuGt2NlxftYVR2LLdP6sk1b63S563cXynBBiGE6ITO1EO7fLChurqa008/nVWrVnHTTTdx2mlqop/vvvuO//u//2PFihV8++23euTFaFSbyrVWqdema+U6W76jy3iXb+mqq67C5XLR0NBAXV0ddrsdl8tFTU0NGRkZQHMW0I6MbyqEEEKIw6PS5mDai0soq2vipN4JXDQ8ndMHJusV+kaHmxveWc2WAvXJzx8/3sDcu8brw1S2Nhxka7QuEPlVza0aJvdNZOmechwuD7PX5fPeigOAmszx9Z/3U16vPsU/IS0qYKvMvslWrKFB1NpdRJhN/P2CE/y6TLRmUHoUO548Q33jtEPucig9ALtyIXclFK4DZ0PghZMHQfoIyBoPPU+FUDWTua3JRaXNQUZseODlfqV7pvbhrlN66TkkXrlyGLd9sA4IHHgRQgjRus7UQ7t8sOEf//gHK1eu5PHHH+dvf/ubPv3CCy8kJSWFp556in//+988/vjjAERHRwPNiS1aqqioAJojNZ0t394yDQ0N2O12EhISAq4vKCiI9957L+A8b3a7+nQjNDRAn0ghhBBC/CZW7Kug6GALgx93lPLjjlIePbs/08dlA/C3L7ew0StnQqPTzfsrcvnb2f0B1BEXAjh/aBpz1hf4Tbc5XHg8CvvKbPq0galWzCYj87YWY3P4Ptj4fF2+/npsj8DJu8xBRmZcNZzvtxZzxehMvyE1A7KVw/6fMZTvhsp9ajLHoo3gtLW9XHxvNYnjCRdDTKY+2eNRmL0mn8/X5bMxv5qZ14/6zYINgE+yyjNOSGHO7WNRgCEZ0b/ZNoUQ4ljUmXpolw82aCNFXHHFFX7zrrzySp566ikWLFigBxu0JI/5+fl+5RVFoaCggPDwcPr06QNAQkIC6enplJSU4HQ6CQ4O9lmmoEC9MRg+fLg+bdiwYXz33XcBtxGo/KFobFSTRIWFhf2q9QghhBCi4+rsTr9pn63NZ/q4bErr7Mxa6//bv2B7MY+c1Q+DwaC3VPA2INXKfy4ZHDDYoChQZ3exv7y5Ut8j0UK/FCvztha3up/9UqxcOzaz1flje8YztmcbmcQVBcp2wO4FsOMbyFtFu/kWQB0VImMUdDsRuk+CuJ4BR4kwGg1cNCKd/qlWHG7P717pH9pNWjQIIcSh6Ew9tMsHG7QPG4iWaNG7zOjRozGZTHz//fcoiuLTvHDbtm3k5+dz8skn+wQVxo0bxyeffMKSJUuYPHmyzzbmzZunl/EuD/D999/7BUEClT8UNpt60xEREfGr1iOEEEKIjquzu/ymbS2spaC6ka0FzS0arh+Xzc6SWpbtqSCvspFdJfX0SY7Uh5r0lhqt5lUwm4wB55fW2TnglRyyW2w4A9OimNIviQ15VUzqk4g5yMiHK3MBtWvAy1cMJdzcids8jxvKdqr5FnKXw67v1eEo22JJgp5T1K4RkSmQfAJEpXd8m0D/VGunygshhDiyOlMP7fLBhkmTJrF9+3bef/99HnvsMZ95WncE7yEoIyIimDx5MgsWLODbb79l2rRp+rxXX30VgLPOOstnPWeffTaffPIJM2bM4OSTT9YDFGvWrGHt2rUMGjRIz6UAMH78eKKiovjiiy8oKioiJUVNuuR0OnnzzTcBfLZ7KLQEkxaL5VetRwghhOjKnG4PBVWNZMaFB8xP0BZFUdiQV016TDgJkW2PeNDocPPx6lyemrtdnzY4PUrvMnH/ZxsZkNrcpXJUdgwZsWEs26N2t/xxRwl9kiNpdPjnc0qLVp8OhQYHDjbUNDo5UNHcsiErLoJgk5E3rh3hU+60AckYDTC+Z3z7x0JRoCZfzbGQtwq2fA51Ra2XT+gHvU9TAwux3dWhKEPkHkQIIY43namHdvlgwx133MFbb73FE088QW5uLqeffjoej4fvvvuOmTNnEhYWxq233uqzzDPPPMPPP//MhRdeyIMPPsjQoUP56KOP+Oijj+jXr59f+csuu4yXX36ZWbNm0dDQwM0338zu3bt5/PHHMRqNPPfccz7lIyMjefrpp7nzzjsZOXIkjz/+OFFRUfzjH/9g48aNXH/99QwdOvRXfW6ttYbkbBBCCHG8WrSjlEe+3EJ+VSO3TerBX07v6zPf7nTz5YYCeidF6s3mP12Tx4EKGxcNz+DbzUU8+/1OzEFGrhqdyZ9O7YU1NNhvO+tzq7hp5lrK65t8pp95QooebFi2p0IPLAAMyYghM655uEUt54Ktyb9lhBZsMAcFTh5daXNwoEJt2RAZEkR0uP8+ApzUO3A+KJ3DprZY2PMD7P8ZavJaL2syQ9YE6HkK9JoK8b3aXrcQQojjQmfqoV0+2DBgwADmz5/PX//6V9555x3efvttQB0RYsKECTzzzDP07t3bZ5lhw4axaNEi7r//fh599FEATCYTN9xwA0888QTh4b4JikwmE9988w1PPPEEM2bMYO7cufp6nnnmGb+uFQC33347FouFxx57jBtvvBFQE0c+/fTT3Hvvvb/6c7tc6s1KyxwSQgghxPHg87X53Dtro/5+1X7/pMyv/7yP/1uwC4MB/nnhIE5Ii+L+zzYB8MpPe/EcTEHgcHl4a9l+imsb+d+V/jmV3lt+wC/QAOpoD6lRoX5DUqZEhZIcFYrTq5VCo1Nt0VBuc9BS6sFgg8sTOCdCSa2d/Cr15q57QkTnWnB4PJCzBDZ8CNu/bj2hozFI7RKRMRpSBkHGGGm5IIQQwk9n6qFdPtgAMHHiRJYtW0ZZWRm7d+/GYDDQq1cv4uNbT3x04okn8vPPP7Njxw4qKyvp3r273t0hkLi4OF544QUeeugh9uzZg9VqZcCAAa3+4BsMBq699louv/xytmzZgtPppF+/flith6dvosOh3qyYzZ0bQksIIYQ4FqzNrfJ5n2QNQVEU8qsaSY0Ow2Q0sGhnKaD2GLj/s01cc6LXaAgB6vWLdpTR5HITEmTymR4SHLjFQZDJyI0TuvPEN9t8pmujO1hCmm+ztBYNpbW+gQkAS2gQlTYH1Q3+ySMB1udW668z4zqQq8lph61zYNMnkL8GHHUBdj5UTeSYMRpSBkO3sRAR1/66hRBCHNc6Uw89JoINmoSEhFaHlAzEYDDQr1+/Tm0jMTGRxMTEDpc3m836CBiHkwQbhBBCHM+6x/tWujNiwrnqzZUs21PBpSMy+OdFg8it9E0iPXP5gTbX2eh0sz63mjHd1Ur3lxsKePzrbVQGaI0AEGwycP34bM4bmsawJxfo011uNZIR4RVsaGhSWzaU1vm3kKiyOfAorY/0sHxfc/eMVoeprC+FXfNg93zYtxiaav3LhEbBgPOh/7lqcCFYumIKIYTonOM22HC8UBQFp1N9+iHdKIQQQhyP+ib7thT8YGUu9QdbD6zNraKmwRmw6wNAkNHg02VhUHoUmw7mXliyu4wx3eMorbXzx483tLkPJqPaujE2wkxkaJA+UoX9YJeJYJNB35bNoc4rDxBsKKhuJN4Swn8uGcw9n270m19UYyfYZODU/klcObqbOtHjhsINsG+hOjxl/mpQ/JNLEpmiJnUccAH0nQZBbSfCFEIIIVrT2XqoBBu6ILfbjXLwCYi0bBBCCHGsc3sUvtlUyPrcaq4dm0V2fAQDWgyZWO+VeHFPaT1bi5qHoTQHGXG4mivifZIj2VrY/OR/ct9ENhfUoCjw5YZC/jC5F5+va2fYRyDY1Ny9Itxs0oMNWksIg8GANSyYSpuDmkb15qwsQADkyw0F3HFyTy4Yls7UAcl8v6WYOIuZTfnVdIuNIN4SwpBu0VjMJtj3E6x5C/YvBnuN37oACIuB3qfD8OlqV4lOjtIhhBBCBNLZeqgEG7ogLSkHQFCQfIVCCCF+H/lVDazaX8mU/kkBR234NX7aWcpjX22lZ2Ik08dlMbZHHAaDgT2ldfzx4w16cGBbYS2f3noiMRG+Nzlp0WEUVKvdJowG2Ftar897eFo//vblVv29s8XwkhHmIMZkx7F8XwX5VY08/vVWahv9R41oSWvZoCiKT1eLfeU2KuqbiLOEEBas5n/QWjuU1voGG8wmI4PTo/X3lpAgLhyeDorCpDSgfBfYymDJRtg5D8q2E1B8H7XlQp8zIW0YGE2BywkhhBCHqLP1UKmpdkEeT/NNktEYOGmVEEIIcTg5XB4uf30FeZWNZMWF8+71ozqWrLCDXl28j5yKBnIqGvhhewlje8Tx3g2jufX9dezxChysyqmktM5OgsW3O0CdvTm5okeBrzcV6e/7JEUyOCOajXnVAOwqqfdZdkthDU+cO4BzXl5Go9PNR6vaGBLSi9ZewGAw0D/Fqg+DCbCtqJYJvRLokRDBwLQoQg8mmZzQK55bJ/VgQKqVlKhQws1BatDC2QiF66F0O+StUlsu1BUF2OpBYTGQPRG6T4Iep0BMZutlhRBCiMOgs/VQCTZ0cRJsEEII8XuYt7WYvIMJF3MqGrjzw/V8/Yfxh239uZUNPu9/2VvBhysP+AQaNOtzq/26UdTafVsiaENhmk1GBqRFcfagFD3Y0NLC7aW8cNlQnjxvIPfN8s+Z0JrQ4ObWA+/dOJr3fslhQ34NQzKiGZEZC8DMG0b7LPPwGb2gaCMc+BYaq6A6V229ULge3IETUfpIHwVjboN+54BJbuOEEEIcGRJsOA54R5eEEEKI38pHK3N93m8uqKG6wUF0eMdyB/24vYSNeWrOhR93lFJlczB9XDbmICNOt4eimka/Zf6zYJf++qTeCSzeVQbAloIagowdy0MwpX8ilpAgLhvVjafmBu6CUO9wYXe6uXBYGh+vymXNgaqA5bxZQoIIMzcHG6yhwdwxuZf6xl4DRSvVpI27F0DRJjBHqAkcG6vAHThxpY/gcEgfCYn9wZoC1jTIPgksHR91SwghhPitdKQeKsGGLsg7iuR2u4/gngghhDhW5VY04HB76JEQQV5lo8/wi5p95TaGdfMPNqzaX0lkaBD9UtTWB098vY23lu0H4J1fcvRWCCnRYZwzOJWSWjva4BDhZhMNDvW3rapB7RoRZDRw39Q+erBhQ141lhDfW5jI0CAuGZHB/nIbG/KqGZgWxcRe8Vw6MgNQgwPbnzidd5fnEBthJjEyhAdnb6awxk5GTDghQUYMBgOPnTOAs15aqq/XbDKSERvOiKwYBqZGYQ0LOpigMkrt/uCwwf4lkLMEynZA2U6oCdANo6mVZI6a2O6QNR6SB0HSAEgbLiNHCCGEOKp0th4qwYYuyHuYEe8kHUIIIcThsPZAJZe/thKH20Pf5Eif5IdRYcH6yAqF1Y0M6xbjs+y8LUXc+v46jAZ4/ZoRJEaG6oEG8O3u8NWGAs4ZnEpxjV2fNqFXPN9vLfFZ58TeCQxMs5JsDaW41s7qnEo98SLA3VN6c+OEbCJC2r6tCTObuPWkHvr7xfefzO6SejLjwjEcHLFhYFoUKx88hSanhziLuXmdbpeanLGhEsoLYe1SKFinBheUdm64LElgMILBBCGRajAh80S1tYIlEeJ6Qai17XUIIYQQR1hn66ESbOiCTKbmGywJNgghhPg1XG4P7y4/wHebi7h4RDqXjuzGCz/uwXFwxIYdxXV6WYMBbp/Ug398twNQgw0tvbFEDSx4FLhx5hq+vGNcq9u2hqk3LSVeIzQMyYhhye5yvXUDwKUjMzAYDEzoFc+stfnYnR7mb1MDEkFGA7dN6oE5qPM5jIJNRvqnWsHjgfpSNX9CVQ5JjVVqVwh7Ndgq1JYKhRvAUdfeKiHECgl91YBCyiDImgBxPf2Gn3S4PIe0z0IIIcSR0tl6qAQbuqigoCBcLhdOp7P9wkIIIUQAhdWN3PLeWjYXqE381+ZWERJk4ueD3RVaOqVvIiOyYvX3uZUN2J1uXlq4G48CV4zq5pPvQFHw6+7g7fstxZxfvoz1udX6tITIEH2YSFBbUkzumwjAjRO6M2d9AS6tzwWQHR/RuUp7YzVU7oOKPerID7nL1RYKHcmj0JIxSA0spI+EXqeqXR8sST6BhaW7y5n1wwZqGp0EGw1U2BzkVzWy7IHJnd+eEEIIcYR1ph4qwYYuKjg4WIINQgghfpVXftqrBxpADQ786ZMN+vtHzurPk99s09+nRIWRGReuv8+tbOSJb7bx4cHkkTN/yfHbRkiwidSoUAq9ukpobA63T6ABIMkaglcsgXMGpxJsUoMJfZIj+cPkXjz3g5o4Mj0mjAfP7Oe7UkVRh4ys2AvVB9SAQnXuwWl71ASNh8KSBJnjICZL7QqRPhLSR0BwWJuLfbmhgC83FPpM65EQoX8mIYQQoivpTD1Ugg1dVFhYGI2Njdjt/jdvQgghREcEGgFCExkSxCUj0qmyOXh50R4AzEFG4iLMRJhN2BxuvxYQNod/7oLcigaGZsZQuKmoQ/tU12IIy5N6+46+cPvJPai1OzixRzxT+iWB2wkHlkPRBijeDPt/DpygsS0x2RDfC6LS1WBCRKIaUAiLhrBYsKaqr4GK+ibqm1zsKK6jT42HrPi2Vx3uNWKFpndSZOf2TwghhDhKdKYeKsGGLioiIoLKykpsNtuR3hUhhBBHWF5lA19uKKBfipVJfRLVURI6oLRO7TpgNMCwbjE+XSDOHpJKZGgw953Wh7E941ibU8VVYzIxGAxkxUewtbC2Q9soqbVTXtfcRSE7PoLp47L425dbA5bPiGluORFkNOBsMbRWsMnII2cNgOo8mH0L7JjbsVwKAJEpav6EmCz13/jekDpEDSZ0wLQXlrC1qPlzf3Vn6/koNJZQ/1utPskSbBBCCNE1daYeKsGGLiokRB0Oq6npEPqYCiGEOGY43R4ue20FBQeTNV44LJ3/u2Rwh5bVggCxEWb6pVh9gg3eo0yM7RHP2B7Nj/D7Jlt9gg0DUn3fn9o/iQUHEzjmVjaQX6Xum8loYOG9J9Hk8gQMNgSbDPRJtvDu9JE0ON2M6xmPNTRYHQFi/89QvAkq90NNPhSsDTwKhCkEuo2BpIEQnaHmVIjroXaD+JVDSf4/e/cdX2V99nH8c1ZycrIHSdh7yBAQAUEEBcQBbsW2rrpHratqbR1t9WlrbWvVtta6Klq1uBW3uAEZMlT23pCQvZOznj8OZ+WcJOckIScHvu/X63k9932f37nv32lIzO/K9buujGRL0HkkWyHSrJaQayO6p7dpHiIiIrESzTpUwYY4lZycDKDMBhGRI5DL5eaz9YX0zLLxw55yX6AB4PUVuyMKNjhdbl9mQ5dUKwPzUoJeH9ToPNDPTupPRZ2dNKuFEwd3YeaIrtz91mpeXrqT4/plcdPUgb5gw9YDVew9uF1jWLc0DAYDVouJUT0z+H53GcO7pdMzy8aE/tmcOaobCWYTUwZkwe5lsPAp2PKZpxME7vCTsabDgJOh7wmeAEPesBbrKLRWXqo16LxrurWJkX49s2xB51dO6huyNURERCReRLMOVbAhTtlsnl9eampqYjwTERGJ1s7iGh79dBNjemfy43Geto5V9Q4+XL2fbulWjumdidUSutff66WlO7nnrdWAp7ZCoOQwNQKcLjdD7v0Au9NNrywbf7twFD2zknxdHbqmWxmYG5za379L08GGfl1SeOrSY4Ou/f7s4fx0Yh/65NhocPi3PizYXIz7YJygd3ay7/p/rxqP0QC2hIPzL98Nix+GzZ/A/tXgaLqeBAC2HBh6Fky7z1dP4VAb0yeTN1buAeCu04aQYUto8T0nD83jrtOG4HS5ueDYHuSmthygEBER6ayiWYcq2BCnrFbPLysqECkiEn8e+2wTr6/YzesrdrN6bzl3njKYHz25mPX7PbUHEkxGjumdwb2zhlJYWY/JYOCEgTkYDrZU9AYaACrrgwsq1jlclNfYSbf50/e/3nQAu9Oz4t9ZUsO87/Yy+9ievte7pCSGZDYkN9OyMhyj0eCrRZBoNpFhs1BWY6eoqh6z0cDYPllcN6WfZ7DLSUrhCtg8H7Z9DYVroK686ZvnDoP+J3m6QeQM8hRytHT8ov2CMT2xO1zkpydxyrC8iN5jMRm5bkr/QzwzERGRjhHNOlTBhjilzAYRkfi1qbDKd/zSkp3M+25vUBeGBqeLxVtLmPnYAt+1847pwUPnHx32flaLkTG9M1m4uRiny80TX23hzlMG+4ITn68vDBr/k/G9grZe5KYl4nI3sU2hlY7tnUmi2cSJg7tw8tA8TxZA6Xb48EH47uXmW1Bm9oFux8CA6Z7/S41sYX+oJZiN/PT4vrGehoiISMwos+EIkJaWBkB5eTN/CRIRkU7J4QzusBAYaDh+QDbr91VSXN0QNOb1Fbs5pncGI3tkBF3vkprIk5eMod7hYuHmYgD+9cUWPl9fyK9OP4rJA3P4olGLytoGJwcCOkTkpiay9UDw3suiqnpyUlpfUPHpy8aC2w1FG2HZI7BunqfAYzjpPSGrn6ew4zGXejIXREREpNOJZh2qYEOcys3NBWD//v0xnomIiETL3ijYAJ72k69fP5HRvTJ5c+Vubp37XciYuct2UVPv78Dws5P6c/O0QSSYjZ66DPmpvq0Y6/dXctmzS5l/22R2FAf/9WHB5iLcAZkMXVKtbC8KDjZsKqhqXbChcj9s/Ag2fQw7F0NNUegYsxUGnQIDZ0C/kyC9e/TPERERkQ4XzTpUwYY4lZ2dDUBZWVlsJyIiImEt31HK3z7ZiNViok+2jQG5Kcwa2Y2URDPV9aEtG/t3SWH0wXaTUwblhr3n97vLfW0kAc4e1Z0Es6f9oslo4M0bjmfed3u583V/BsH0h78Kuc+XGw9wVL6/IGRuWiLf7S4LGrPlQBUT+mdH9mEr9sEPr8K6dzxdJJrSdRQcdQaM+Skk5zQ9TkRERDqlaNahCjbEqcxMzy+kxcXFMZ6JiIg0Vmd38vOXVrC3PLh40pcbD/Cvi8dQ0miLBAR3f8hKDu5ycHSPdL7f7UlX9L43JyWRAbnBRR2TEkzMHtuTdJuFa19YHvSa1eLJfrA73SzdVsK2gEyGrulWSqqC59R4W0WIygJ/gGHXUsK2prRmQI+xnuKOQ8/S9ggREZE4F806VMGGONWjh+cXtj179sR4JiIi0thLS3aGBBoA5q8r4EBlPbX20MyGVKv/P8nuRsUaLx7fm0erNgUVdRzfN8tXALKxGUPzmNg/m0VbPL8I9OuSzP+dNZzP1hfy9IJtAL6aDb2zbeSlWjn3mO7M/XaX7x5lNaEBEdxu2PoFLP8PrH8fXPbQMblDYchMGHQadBsNRmPYOYqIiEj8iWYdqmBDnOre3bO/dffu3TGeiYiIBKqqd/CPzzf7zudcMY43V+zmrVV7sTvdfL6hMOz7TEZ/4MDhCg42rN1XwS9PG8JNL6/0XTtpSPitFgAGg4F/XTSGJ7/eQu/sZM4Z3R2LyUi9w+ULNgCYjQYenj0So9HA+H7ZLLxrKr9/by244bYZg/w3LNnmqcOw/Dk4sC70gV2GeDIXRsyGnAFNzktERETiWzTrUAUb4pS3MEdRUZjCWyIi0mYOpwujwYDRGD57oClzFm33bXWYdXRXpgzqwtYDVby1ai8Au0rCt4oKTFKwmIzcNHUAj33mCVqYjQbOOLor/1m4jZU7yzAZDUxsoZ5Cus3CHacMCbo2vl8WeWmJFFTUMygvhV+ddhRjemf5Xu+ekcTjF43xnFQVwvJXYOV/w9dhSO4Coy+GURdBzsBm5yIiIiKHh2jWoQo2xKmcHE9hrfr6esrLy0lPT4/xjEREDg97ymr5w3vr+HDNfmYMzeNfF4+J+L11dif/WejJHDAa4BczBgNgNvm3EgS2nAxkdwZnM9w2YzDDuqezYmcp10/pj8Fg4N8Xj+GRTzcxrk8W3TKSov1o2BLMfHzrFAoq6hiYmxK6DcPpgM3zYfHjsO0rwtZh6Dkexl8HQ2aBOSH0dRERETlsRbMOVbAhTiUnJ5OWlkZFRQX79+9XsEFEpB3sK6/l9Ee/przWU4vg03WFuN3uJmsjgKdrg9looHd2Mq8u303RwUKLp4/oSt+cZACcAa0uq+odYe+zuzQ04+GUYfmcMizfd56bZuUP54yI/oMFSE+ykJ5k8V9wNMDGD+GHV2Drl1BfEfqm3GEw4jwYdCrkDWvT80VERCR+RbMOVbAhjmVlZVFRUaH2lyIi7WRzYZUv0ADQNcMaNtDwzIJtzF22k6lD8njiyy0AnD+mB5+uK/CNuW5Kf99xncMfbGgIOA60paXuD+2tbBesehGWPQPVYepIZPWDYed4Mhi6jQ7e5yEiIiJHrEjXoQo2xDFvFKm8vDzGMxERiV9r9pazYmcZ5x/TgyH5aUGv/Xhcr5DxK3eW8sC7awHYWFDlu/7acn+hpAn9shne3R/ptwcEGOqaCDYcqKynut5BcuIh/E9z4XpY8yZs/AD2fRf6ui0b+p3oKfQ4cIY6SYiIiEiISNehCjbEsbQ0zy/FFRVhUl5FRKRFhRV1zHxsAQA7i6u5e+bQoNdPGJgTdO5yufnVGz+0eN+LjgsNUng5nOGDDQC7S2sZnJ/a4v2jUrHPE1z44TXYsTD0dYPJ06pyzGXQ7yQwmtr3+SIiInJYiXQdqmBDHEtN9fxCWllZGeOZiIjE3o7iaj5ZW0BFnYNnF2yjf5dkph2Vx9mjutMr2xb2PU9+tdV3/NTX25g8qEvQ65V1wfUV5n67i/X7W/6Z2/g+gTsQnAFtLc8e1Y2vNhVRUt2AyWggJ6WdCi7aa2Hdu7DyhaYLPXYdCUPOgJEXQkbTwRERERGRQJGuQxVsiGPKbBAR8bA7XUz58xdB177bXc53u8v595db+Oz2E8lLs4a8b2tRcJ2ES55ZGnS+dFsJx/XztJjcUVzt2z7RkjSrJeg8sH1mTYPTdzzr6G48eN7RfLHhAD0yk8hOSYzo/k3audjTqnLt2+ELPeYMhmMvh6POhPTubXuWiIiIHJGU2XAESElJAaCqqqqFkSIih7dvthQ3+Vp1g5M5i7Zz56lDQl6zN7OlAWDRliJumjYQt9vNrXNX+QIF4/pmsXRbiW9cmtVMRUAWRG2Dk6QE/3YEZ0BbS5fbf2wxG7FaTJw63N9xolV2LYPP/w+2fhH6WmZfOHo2DD4Nuo5SoUcRERFpk0jXoar8FMcyMzMBKC5u+pdsEZEjQUl1Q8i1HplJvuOXl+5kZ3ENS7YW+7YxOF1uVu0q84255LjeZCUnMGlADhk2T2bCih1l1DY42VNWy4qdnrFd063856djg55V0Wi7xdLtJUHn1QHZDEkWfxDC1JaFf20pLH8OnpoKz0wPDjQkpMCoi+Cn78NNK+GkX6ujhIiIiLSLSNehymyIYzk5nsJlCjaIyJGue0BgwWvm0V0pKK/jrVV7Ka2xM/nPnwMwsmcG//jxaMpr7b6aDKcOy+eBs4fzwNnDAbjr9e/537JdNDhdLN9RSp3dHyw4c1S3FjtGfLu9hCkBdRucLn8GhTMgsyHBHGXMv6EGNn3kKfa46WNwNgqyZPaByXd6WlYmhK9TISIiItIWka5DFWyIY6rZICLi4XCGFkDsmWlj6uBc3lq1N+j6d7vKuOaF5cw+tofv2nH9soLGTOifzf+W7QI8WylMATUXju6eAcBN0wby2KebALjhxP443W7+/aWn4GSvrOCFviEgo6C2iSyHJjntsPEjTx2GDe9DQ5iUxfwRMO5aOPpCMLdTkUkRERGRMFSz4Qigmg0iIh51DmfIte4ZSYzsmYHRAK5GsYh1+yr43Tx/scdRvTKDXp/Y39/ycsHmIjJs/gX8yJ6e3tK3Th8Ibjdr9lZw0XG96Z6RxJWT+rK/vI6je2QE3a/B4c9saAioExFY1yFE1QH44RVY/ASU7wx9PSUPhp/nqcegWgwiIiLSQSJdhyrYEMeSk5MBqK6ubmGkiMjhpcHh4utNB8hPtzKsW3pQtoBXt4wkrBYTvbOT2VbU9M/JBJORoV3Tgq51SU1kSH4q6/dX8sOecswHMxuykhPonuHZsmEwGLhtxuCg9+WmWslNDe16ETg/i9G/dSIx3DaKnUvgm7/D+vfB3ehzWdPhqDNg+PnQdzIYI8iMEBEREWlHka5DFWyIY1ar5xfaurq6GM9ERKR92Z0ujAZD0PYFr8/WF3DFc98CYDTA17+cSnFVfci4/HTPz8heWTZfsCHBZGTyoBzmryv0jTu6R3rY2gnHD8hh/f5K3G6wH9ymMSQ/NWhLRGs/G3g6WKRaA/4zXLYLPvoVrJsX+qaBM2Ds1dBvCpjb2B5TREREpA0iXYcq2BDHtI1CRA5HWw9U8dP/LKO0poHXrpvI4PzUoNe9gQbwbI8wGQwUVIQGGxJMngCCI6A4Y1qSmT+cM4L56z71XQss5Bjo+AHZPLNgW9C1Mb0zw45tiTEgaJJoMfKr04Zw6YQ+JJkNnraVy5+DH14FZ8DnSMmHkT+CkT+G3NC2nSIiIiKxoG0UR4CMjAwAysvLYzsREZF24nK5mfrXL33nK3aWBgUbXI2KLxzdI538dCtFYTIb1u+vYHSvTGoCCzImmMhNszL3muO4+nlP0OLcMT1C3gswrm82yQkmX9vKWUd35aoT+rXqc50xsiunDc+nS2oig/NTMdZXwqI/e4IMlfuCB9tyYPpvVexRREREOqVI16EKNsSxpCTPvuGampoYz0REpH3U2INrFAzKC85q+GZrcIul00d0BaCgIjSN7/MNBxjdK5PqeofvWnKC5z974/tls/CuqSSYjSSaw9c9SEk08+9LjuWLDYWcNao7I3qkR/+BDpqYWQn7VsHuEli8DDZ8AHVlwYMS02HMZXDCLyApo9XPEhERETmUIl2HKtgQxxITPft26+tD/6InIhKPzI1qNDQu3PjSkuCuDF9uOMB1U/qzrzw02LCvrBaAqrqAYEOi/z97qVZLi/OZNDCHSQNzWhwXltsNa9+CBY94Ag3hGM0wYLqn6OOwcyAhuXXPEhEREekgka5DFWyIY94vst1ux+12t7lomYhIrDXOXPhudxnH9csGoLCyjo/X7g96fcm2Yh6dv4n1+ysBMBkN9MhMYkdxDSN7ZmB3uiiqavCN/2F3B2w7c7lg08ew4G+wa3H4MRYbDD0LptwJWa3bmiEiIiISC5GuQxVsiGNms//L53A4sFha/iudiEhHKq1u4OkFW8lLs3LWyO6k25r/OfX5+sKg81W7/MGGv32y0dcVwsvlhr/N3+g7//G4ntw7ayiFFfX0zLLhcLqwmAx4yzY0OF3U2Z1YLYegZWTpDlgxB75/Bcp3Bb+WPwKGzILUfMgeAD3GqquEiIiIxKVI16EGt9vtDvuKdHrl5eW+4hw1NTW+vTMiIp3F3W/+wIsHtz5YLUbOO6YH950xtMk6CVP+/Dk7ioP3//XLSaaq3kFhpSdVL8li4qNbJvOPzzfxyre7feOG5Kfy+vUTg7ZKAHyzpZiLn1mC0+Umw2ZhxT0nB3WHaBOnHda9A6tehs3zgUb/Sc0eCKf8HgbOoKTGzs7iavaU1bF4azGlNfX84ydj2mceIiIiIh0k0nWoMhvimMnk/2XdFdDaTUSkM3A4XXyw2r/toc7u4sUlO+mbkxy2q8OWA1UhgQaArUXVQee/PXMovbJtPHT+SH48rhePzN+E0+XmwfNGhAQaACb0z2b5PdP5eG0Bx/TKbJ9AQ8k2WPE8rHoRqgqCXzOYoP9UGHslDJwBRhNzFm3n/nfX4gzopnHy0Ly2z0NERESkg0W6DlWwQUREDokVO8soqW4Iuf5/761jc2EVvztrGH/9eCNfbTzAXacN4etNRb4xQ/JTqW5wUF3vxOF0kWA20jcnmfOO6cHsY3v6xo3ulcmcK8a1OJcMW0LQ+1rF0eDJXvj2Wdj8SejraT1gzE/hmEshNTiQ8MOe8qBAA0CWTW0tRURE5PClYEMcczr9LeKMRmMMZyIiEmr+Ov9f/P96wUh+8ep3vvP/LdvFh2v2U1ZjB+Cn/1nmey3RbOTFq8aTndIJahq4nLBrCfzwGqx5A2pLg183mGDI6TD2auhzAjTxszhcMkVWioINIiIiEn8iXYcq2BDHHA5/OzcVhxSRzqKmwcE7q/by5FdbfddG9coIGecNNDR2wbE9YhtocLth5zew5k1YNw8q94WOSe8Fx14Ooy4KyWIIx2wK/Q9xdrKCDSIiIhJ/Il2HKtgQx+x2/y/qgRVBRURi6Zrnl7Ngc1HQtW0Hqnng7OHc+9bqFt9/7eT+h2pqLdv9Lbx/O+xdGfqaOQmGzISjL/TUZDC17edutjIbREREJA5Fug7VCjWOeb/IymoQkc6ios7Owi3BgYZLjuvNpIE5WC0m8tOsfLGh0NehorFZR3elZ5atI6YarHwPfHo/fP+/4OtGCwyYDsPO9gQaElNbdXtzmH0UuanWVt1LREREJJYiXYcq2BDH6urqALBa9QuriHQOq/eU422oPKZ3Jq9cOwFTwEL75KF5nDw0j+U7Slm/vxLwtLb8yfhe/LCnnHtmDu3YCTvtsPhf8MUfwR7QCSN3KBx/Cww+DaxpbX5MkiW41WdOSgJH90hv831FREREOlqk61AFG+JYQ4OnyrsyG0Sks1i7t8J3PPvYHkGBhkAHKut9x9kpCWFbYR5yu5bBu7dCwQ/+a9YMOOnXcOyVbd4mEWjK4C48u3AbZqORi4/rxTWT+5Nq1c9uERERiT+RrkMVbIhj2kYhIp3ND3vKfcfDuzf9l/vigJaYHbqdwO2GHYtg6b9h7TuAtx2lAcZdDSf+CmxZ7f7Yif1z+OZX07AlmLAl6D+9IiIiEr+0jeIIUFPjSflNTk6O8UxE5HCyp6yWX772PXlpVv547ggSzC231m1wuPh2RwmfrSsEIMFsZFBeZPUNOqRQotsNmz6Gr/4Cu5cGv5Y/AmY9Cj3GHNIp5HSGVp4iIiIibRTpOlTBhjhWVlYGQEZGRkznISKHD7fbzfEPfuY7v2xib9bvr+Td7/fxk3E9OXV415D32J0uLn12CYu3lviuNThcWMK0ewSorAtueblyZ1n7TD4cl9PTvvLrv8L+74NfS86F42+G8de165YJERERkcNZpOtQ/XYVx4qLiwHIymr/lF8ROTLtLq0NOv/5yyvZUeyJXu8srubU4V35eM1+HvtsE3tKazl1eD4ZtoSgQIPXxoLKsNkNiWYTeWmJFFR46jZUNzhCxrSZox5WvQgLH4PSbcGv5Q6FSbfC0LPBrPaTIiIiItGIdB2qYEMcKy/37I3OzMyM8UxE5HCRlxZcP8EbaADolZ3Moi1FXPPCct+1l5fuwnCwBqTZaMDh8tRAyElJJDs5/EI+wWxk7jUTuOaFb9lYUMWonhnt9wHcbljzJnx8L1TsDn6t6yiYfAcMPh2MLW8NEREREZFQka5DFWyIYyUlnr8kahuFiLQXQ/jmEQDcecpgNhVWhlz3trq84cT+3DZjMIUVdSQlmJrtttAnJ5kPbp7M5sIqBuamtHXanhaWP7zmKfy4d2Xwa32nwKRboN9JzX9AEREREWlRpOtQBRviWEWFp8Wcgg0i0l62FVU3+VqD08X6fcHBhlOG5fHRmgIAZgzLByA3LbLuEiajgcH5kRWRbNa2r+H9O+DAuuDrA6Z72lh2P7SFH0VERESOJJGuQxVsiGNVVVWAulGISPtZHdC6srFzH18Uci2wCGRaM5kMh8TOxfD5H2Dbl8HX84/2tLAcfJoyGURERETaWaTr0MMy2FBfX09DQwMpKSkYWvhF0+VyUVNTQ3Jycotjvaqrq7FarZhMpojGNzQ04HQ6SUpKimh8pKqrPX+BTElphxRkERFg6wF/ZsOQ/FRumjaQG15cEXbsiO7p1NmdvvOkhMh+JrZZ4Xr45D7Y9FHw9W7HwCm/h14TFGQQEREROUQiXYceNhWy7HY7L7zwAiNHjsRqtZKWlkaXLl04//zzsdvtIeP37dvHjTfeiM1mIzU1le7du/PYY49RX18f9v4Oh4NnnnmGvn37kpKSgtVq5fLLL2fbtm1hxwMsX76c0047jcTERGw2G8cccwzvvvsubu8G5zY6cOAAoAKRIgIHKutZtr0Ep6t1P1+q6x00OFys31/hu/bkJcdy+oiujO8bvtLwnrJaKur8nSRSrYc4fm2vhfm/hSeODw40ZPaFs/4JV82H3hMVaBARERE5hCJdhx4WmQ2VlZWceuqpLFq0iNzcXK666ipsNhsbNmzgvffew+l0YrH403t37drF2LFjKSgo4LzzzmP06NG8+uqr3Hzzzbz33nu8//77QVkLbrebyy67jJdeeomBAwfywAMPsHHjRp577jneeOMNFi9ezFFHHRU0p/fff58zzjgDs9nMTTfdRFpaGk888QRnnHEGf/jDH/jVr37V5s/t/SLn5eW1+V4iEr/q7E5Oe/QriqoaOLZ3Jo/+eDTdM1rOpHK53MxfV8B/l+zkq40HGJCbwt4yT+vL5AQTPTI99/j7T0bz6bpCspMTGNkzg5+/tJKl20soqW5gd4mnW0WSxYTVcggzG7YvgHm3QPEm/7W0HjDlThh1EZgOi/+ciYiIiHR6ka5DD4vfzm655RYWLVrErbfeyh/+8AesVn9xstLSUhISgtuv/epXv6KgoIBHH32Um266CYA777yTCy64gLfffpuXX36Ziy++2Dd+/vz5vPTSSxx//PF88sknvu0Qs2bN4sILL+Smm27ik08+8Y1vaGjg+uuvx2QysWjRIsaM8RQn+/nPf86xxx7Lb37zG3784x/Tp0+fNn3umhrPL/mq2SByZNtRXENRVQMA3+4o5YYXV/D2z45v8X2/nbeG57/Z4TvfXFjlOx6Yl4rR6MkQyE218uNxvXyv9cmxsXS7pwrx3vI6AGyHYguF2w27l8HCR2H9u/7rpgSYdCtMug0skRWjFBEREZH2Eek6NO63Uezfv59nn32WESNG8Oc//zko0ACe1A5jQD91u93O66+/TmZmJjfccIPvusVi4c477wTglVdeCbrH3LlzAfjFL34RVHfhggsuYMCAAcyfP5/i4mLf9SVLlrBz505OP/10X6ABIDc3l2uuuQa73c5bb73V5s9eWloKQHp6epvvJSLxq7rBEXT+3a4yth6oamK0R2WdnbnLdjX5+uC8prtE9M4O/Q9Lu9dr2L4AnjgBnjk5ONDQfQxc+7Wny4QCDSIiIiIdLtJ1aNxnNrz33nsAzJ4927f1we12N1nsceXKldTV1XHOOedgNgd//PHjx5OTk8OiRYuC7rFw4UIsFgszZswIGm8wGJg1axaPPPII33zzDbNmzfKNB3zngWbNmsW9997LwoULueWWW8LO8e677wYgKSmJtLQ0rFYrFouF5ORk0tLSOO6440hPT/cFOLp06dLi/04icviqqA2tS3PPW6t55EejyE31LMhrG5ys3VeOyWgk1Wpm+fZS6h0uAE4YmMOpw/O5+83VvvcPzGu64I93e0Wg1PbqRFFfBR/9ClY8H3w9JQ+m3uPZMmHsoEKUIiIiIhLE7XZHvA6N+2DDBx98AMDEiRO5/fbbefHFFyksLKRfv35ceuml3HTTTUERlyVLlgDQv3//kHuZTCb69OnDt99+y+bNmxk4cCDl5eWsX7+enj17hk0T8d5n8eLFvuBCc88IHN+UBx98EJfL1eTrK1eupFevXjgcnr9m5uTkNDlWRA5/gR0hvBZtKea4P3zKpIFd+PXpQ7jp5ZVsLAif7XDbyYPokpoYdK1fl6bT4vqEyWxIT2qH/5xs+ADevwPKAzIuuo6C8dfC0LMhwdb2Z4iIiIhIq5WWlka8Do37YMPOnTsBuPXWW9m4cSPnn38++fn5vPPOO9x33328+uqrLFq0yNeWw1vMIisrfHV17/Xi4mIGDhxIUVFRxOO9mntGSkoKZrM5aHwgt9vdbKABPF9U7zPS09NDto6IyJGlwRm+A4XLDV9tPMBXGw80+/6RPTJCGjgM7dp0Wly4QERaWzIbqg7Ae7fBunf81yzJMON+GHMFGON+x5+IiIjIYSGadWjc/wZXW+upnL527VqWLFnCCy+8wJ///GfWrl3LzJkz+eGHH3j22Wd94xsaPEXUmvofxmbz/OXM2wIz2vEtvcdgMGCz2Zpssel0hv6FsrGUlBQqKysBSE1tel+1iBwZXFG0u8xKTgi59uXGAyFbzyrrQrdmeKVaLeSkBN8nJbEVsWu3G9a+DY8fFxxo6HciXPc1jL1KgQYRERGRTiSadWjcZzZ4tzbMnj2bo48+2nfdZDJx//3389577/Hyyy/7uk54x5eVlYW9X0lJSdC4aMe39B6Hw0FFRUWzX5yLL74Yh8NBTU0NlZWV1NXV4XA4KC8vp7q6mtTUVKqqPOnQ3owNEYl/89cWsHxnKddN6U96UuSZAjUN4YOUPxnfi9eX7/bVZgD48o4TMRuNjP/DfCrqHOSnWcPWZ/h6UxEDmykS2SvL5uuAAZBuizKzoXQ7fHxvcJDBlg2n/glGnE9IqoWIiIiIxFw069C4DzYMGjSIJUuWMHz48JDXhg4dCsCGDRt81wYOHAjg2x7RmHd7g7e2QteuXbHZbC2O997Xe/zFF1+EfY83OBE4PpDZbOaFF14I+1qg8vJyQJ0oRA4X+8vruOHFFTQ4XWwqqOTpy8ZG/F5jE+tytxumD83jve/3+a55Czl+/9tTDo7xF8M9rl8Wi7d6fkZV1TtoTt+cFFbsLPOdJydE+J+Tyv3w6f3w3f/AHRAkGXw6nPEopORGdh8RERER6XDRrEPjPj/1hBNOAPwRlkDV1dVA8HaG44/39J7/5ptvQsaXlJSwfv16hg0bRmZmJuBpiTl+/HiKi4vZtGlTyHsWLVoUdN+WnhFufGt4gxbeeYpIfPt60wEanJ4MhPnrCimsqIv4vYFJAHecMpiJ/bNJspiYflQuQ7umhTwn+L3+N//3yvFcN6U/pw7L50djezb7zEGNsiFG9cxofpIuJyx5Ev5+LKx60R9oSMqE8/8DP3pJgQYRERGRTi6adWjcBxtOPPFEAD755BPc7uB9yx9//DEAJ598su9az5496du3L4sXL2bXruAe82+99RZOp5PJkycHXZ8yZQoAr732WtD1iooKPv74Y9LS0hg5cqTvuvf9r7/+ekixR+89Gj8jWt4tGgo2iBwePltfGHReFqadZVMCt0l0Tbfy0tXHseZ3pzDtqDy6ZQTXjvnv4h1N3sdsMnLXaUN44pIx5KY1X/Bn+tA8LCYDJqOB/zt7ONOH5jU9eP9qeOZk+OAOaPDs88OaDif+Gn6+Aoafq20TIiIiInEgmnVo3AcbBg4cyAUXXMCyZcu4++67qaysxO128/XXX3P77bcDcNVVVwW954477sDtdnPhhReybds2wBOYuOuuu7BYLNxyyy1B46+99lpSU1P54x//6AsW7Nu3jwsvvJCamhp+8YtfYDb7U4j79u3L+eefz/r167n++uupqqrC6XTyyCOP8NJLLzFo0CDOOuusNn3uiooKANLS0loYKSIdqaymgUfnb+LtVXsifk91vSMk2FAeRbChISDYYDF5fqwbD+6tOHtUdx46z1/P5phe7ROg7N8lhUV3TWPRXVO5+Lje4Qe5XPDZ/8G/J8Oe5f7roy+Bn6+EE38JtvCdfkRERESk84lmHRpxzYYLLriAFStWtGpCW7ZsadX7IvXUU09RXl7OH//4Rx5++GFSUlIoLi7GZDLx6KOP+rZaeF133XVs2LCBv//97wwYMIDMzEyKi4vJzMzkv//9L4MGDQoan5+fz6uvvspll13GBRdcQFZWFhUVFTgcDi699FJ+/etfh8zpySefpKioiCeffJLnn3+ehIQEKioqGDx4MK+//joWSxvaxOGPKKlmg0jnUVLdwIl//pyKOk+9g2P7ZNE9I6nJ8R+v2c/Hawsoq2kIyk4AqKrz10z4fEMhN764grNHd+fnUweSnx6cdRBYINKWYAp6zWAwMHtsT84f04PyWjuZYbpRtFaX1MSmX3Ta4Y1rYM0b/ms5g2DWI9CnbdvIRERERCQ2olmHRhxssNvtvpaOXk6nk337/IXHsrOzqaiowG73/EUuLS2tQ/7ynp6ezkcffcSCBQt4/fXXqaysZOjQoVx00UXk5YWm9hoMBh555BGuv/56nn32WUpKShg0aBDXXHNNk/+jnXLKKWzZsoVnnnmG1atXk5aWxiWXXBK0fSJQZmYmn332GZ988gnvvvsudrudiRMn8uMf/zgoC6K1vIU5tI1CpPOYs2i7L9AAUFLV0GSwYXtRNde/uAJnE20rKw62nly/v4LL/7MMgBeX7GRfeR3P/jS4eGR1QDHHplpQGo2Gdg00NGv3cnj/F7B3pefcYIIpd8KkW8HcTIBCRERERDq1aNahEa9633rrraDz2tpaZs2aRZcuXXjggQeYMWMGVqsVl8vFxo0b+etf/8obb7zB3Llzo5t9G0yaNIlJkyZFPH7w4MH86U9/inh8cnKyr4VmJAwGAzNmzGDGjBkRvydS2kYh0vmkWoN/pCYnmpoYCf/4fHOTgQaA0uoG6uxObp37XdD13tm2kLF2p/8+ZlMMax/UlsGnv4Nv/wMcnJPZCrOfh0GnxG5eIiIiItIuDsk2isYeeughli9fzrZt24KiGkajkSFDhvDUU0/hcDj4yU9+wpYtWzCZmv6lW6LnTV9RsEGk8xjaLfj7MdMWPpNgV0kNb65svqZDcXUD//x8M+v2VQRd/+nEPiFjG5z+bRSJ5hj8rHW54LuXYf5voDqg20XuUDjjMegZeRtPEREREem8olmHtjrY8M4773D22Wc3mz5xxRVX8Nxzz/HDDz8watSo1j5KwvBGlDIyMmI7ERHxGdYteBtWepKnNkuDw8Wtc1exr7yW88f0ZMXOUl9Wwy3TBzKsWzpXP/9t0HsLK+pZsLko5Bnr91fSOzs56FpghoSxo7s6HNgA794KOxb6r1mS4aRfwfjrwNS2+jQiIiIi0nlEsw5tdbChrKzMF9VoSmlpKeDf1yHtp6qqCoCUlJQWRopIR/EGF7y8IYAP1+znvR889W1W7CzzvZ6cYOLyiX1Jt1lY/btT+GZLsS/o8NmGQg5U1oc8Y92+Ck4Zlu87/2JDIS8v9bfxbbyV45DZ8Q188w/Y8AG4/ZkVHHUmnPpHSO/RMfMQERERkQ4TzTq01a0vjzvuOObNm9dkh4r6+noefPBBbDYbw4cPb+1jpAneiFJqamqMZyIiXm53cA2GHcXVAHy6riDs+FOG55Nu8wQoUhLNnDi4i++1wEDDtVP6+Y7X7vVvq3hl2S5+erB4JECfbFuz3S/aRU0JvH0j/OdUWP+uP9CQ2QcueRMufEGBBhEREZHDVDTr0Fb/CexXv/oVr7zyCpMmTeLyyy/nlFNOoXv37pSVlbF69Wr+8Y9/sHnzZu68806ys7Nb+xhpQmVlJaBgg0hnUh3QghJg7b4KemXZ+GLDgbDjj+sX/LPRYjKSajVTGdDRwmiAq0/oxwvf7KCmwcmag8GG6noHf/54Q9D7r5zUF6PxEG6j+OE1+PCu4LoMqV3h2Cth4o1gOcSBDhERERGJqWjWoa0ONgwfPpy3336byy+/nMcff5zHH3886HWDwcCNN97I//3f/7X2EdKM2tpaAJKS9Mu9SGdRXBW87WHdvgry0qyU13raWJ4+Ip/3f9jvHxCmGUVWckJQsOH4ATnkpCQytGsa3+4oZU9ZLSt2lvL3TzcFZT/84ZwR/Hhcz/b9QF5OuyfIsOxp/7XENJh2H4y5HEwdtHVDRERERGIqmnVom35DPP3009m1axdfffUVn3zyCQUFBSQlJTF27FhmzpxJXl5eW24vTXC73djtnsWLxaLiayKdRVGjYMPyHaWYAgo25qZag16f9/1eZo8NDhCkJAb/WD7j6G4AjOiRzrc7PHVwzn18ke/1BLORj26ZTN+c4KKR7aZgLcy7GXYv9V876gw47SFI63ZonikiIiIinU6069BWBxt+/etf43A4eOihh5g+fTrTp09v7a0kSt4vMEBiYmIMZyIigRoXdPxuVznV9f6tFScMzOG5Rdt95ysDikV6DcxN8W2VOHd0d84b46l/MKpnRthn3nbyoEMTaHC5YMHD8MUfwXUw08KUALP+BqMvbv/niYiIiEinFu06tNXBhrlz5zJs2LDWvl3awOHwp1ibzUpfFuksDlQ1BJ3X2p38sMfTjWdIfirTjsrjLxeM5PZXvwMgwxYaEf716UfRr0sKY3pncvyAHN/100d05auNRWwsqKRXlo0+OTZGdE8P6kzRbmrL4PUrYfN8/7WsfnDOk9BzbPs/T0REREQ6vWjXoa1eqfbv358DB8IXPZNDK7DivdHY6oYiItLOwrWq9JrQ31MM8vwxPZh+VC4LNheFzVbITbNy07SBIdctJiN/nT2y3ebapPI98NJsKFh98IIBTvgFTL4DLNZm3yoiIiIih69o16GtXqlee+21LF68mG+//ba1txAROawcqKxr8rXAwEKGLYFZR3ejR6atA2YVIUcDLHkS/n2CP9Bgy/a0s5x2rwINIiIiIhKVVmc2TJw4kauvvpqpU6dy0003ceKJJ9KtWzdMJlPI2MGDB7dpktI0l8sV6ymIHPFqG5z88/PNvLx0V5NjhndP78AZRWnnYk8RyAPr/dcyesPFb0DOgNjNS0REREQ6pUjWoQZ3YC5EFC699FJeeOGFiMa28hHShPr6eqxWz18ZS0tLycjIiO2ERI5wv5u3hv8s3O47756RxORBOUHBhy1/OB2T0RDm3THktMNnD8DCR4OvDzsHTv8LJOeEf5+IiIiIHHGiXYe2OrPhxBNP9D1IOlZCQoLvuKGhoZmRIhItt9vN7a9+z7p9FTz6o1EMzEtlydZi9lfUcfqIrlhMwbvPHE5XUKAB4I/njuDoHulBwYbvd5cxuldmR3yElrndsO0rmP9b2LvCf73baJj5V+g+JmZTExEREZHOKdp1aKuDDVdccQVXXHFFa98ubWAwGDAajbhcrqD2IyLSdv9btovXV+wG4E8fbuCXpw7mJ08vwely89CHGzh+QDYjuqdz1ujupFktLNlWEvT+W6cPYvKgLgD0yrKxs6QGaL54ZIfauwo+/BXsXOS/ZrTAtPtgws/AGLoVTkREREQk2nWo+ibGqcTERGpra6mv7yQLGJHDxJcb/F12lmwt5sPV+3G6PFvB9pTV8sq3u3nl29385eON/PfK8by2fLdv/B2nDOZnJ/lrHHxx+4m8vGwntQ1Oph+V13EfIpyqQvjkN/DdS8HXswfCuf9WNoOIiIiItCiadaiCDXHKarUq2CByCCRa/NskauxOPt9QGHZcea2dM/6xwHeeZDFx+fF9gsYYjQYuGt/7kMwzYrWlsPgJ+Oaf0FDpv57VH076NQw9G0z6T4GIiIiItCyadWibfsOsqanhpZde4q233mLz5s1N7tvYunVrWx4jYVgsFgBtoxBpZwkBNRmcLjcrd5UB0DcnmTmXj+NAVT1XzVlGaU3w995PxvfCltCJFu1uN3z3P/jwl1BX7r9uTYcpd8HYK8GcGLv5iYiIiEjciWYd2urfjCsrK5k8eTKrVq3CYrFgNBoxGo2kpKRw4IAnDTk9PZ309E7c7i2OeYtz1tXVxXgmIoeXfeXB31PeZjqnDc+nV7aNXtk23v7ZJM765wJKa+xYLUZ+cfLgkKyGmKotg3k3wdq3/deMZhh9MZx0D6R0idnURERERCR+RbMONbY4oglz5sxh1apV3H333VRVVTF16lTOPPNMCgsL2bhxIzfccAMWi4U333yztY+QZqSmpgJQVVUV45mIHF72ltWGvX7SkFzfca9sG+/edAL3nzWMT26dwtWT+2E2tfrHafva+gX86/jgQMOIC+DnK+CMRxVoEBEREZFWi2Yd2urMhtdee40hQ4Zw//33YzR6fsl2uVwADBw4kH/+858cOHCAiy++mDVr1mAwdLL+8nHO+0WurKxsYaSItKS0uoG95bUM7ZoWktkAkGY1M7pnRtC17hlJXDqhT8dMMBJOB3z5IHz1F+BgOoY1A878Oww9M5YzExEREZHDRDTr0FYHG3bs2MHEiRN9gQaj0RjywKuuuopTTjmF9evXc9RRR7X2URJGSkoKoGCDSFsVVdUz67EF7K+o40dje1Jrd4aMuWfm0M6TuRBOVSG8cllwO8u+U+Csf0BGr9jNS0REREQOK9GsQ1v923NiYiJmsz9WkZOTw65du4LGJCQkALBv377WPkaa4P0iaxuFSNvcP28t+ys82Qz/Wxb8M2x83yzmXnMcs8f2jMXUIrNrKfx7ij/QYDTDtPvgkrcUaBARERGRdhXNOrTVmQ2DBw9m/fr1vvNJkyYxZ84cvv/+e44++mjcbjcvvPACAD17duJf1OOUtlGItJ7D6eKNFXt4aelOVh3sNtHYL08dwvUn9u/YiUXD7YYlT8DH94LrYDXg1G4wew70HBfbuYmIiIjIYalDtlFMnTqV2267jT179tC9e3fOOOMMUlJSGD9+PKeffjo7duxg+fLlHHfccQwcOLC1j5EmKNgg0jpr9pZz52vfs2ZvRbPj+ubYOmhGrVBfBe/cCGsCCvD2Ph7O/w+k5sVuXiIiIiJyWOuQYMPFF19M165dqa+vByAvL4/33nuPX/ziF7zxxhsYDAZOPfVUnnjiidY+Qpphs3kWQjU1NTGeiUj82F1aw4+fXExFncN3LcFs5OSj8liwuYjyWn+/4L45KbGYYvPcbk+A4ZPfQPlO//Xjb4ap94Gp1T/SRURERERaFM06tNW/mWZnZzN79uyga5MnT2bp0qUUFRWRmJhIWlpaa28vLVDNBpHoVNU7+NlLK32BhiH5qfzmjGGM7ZOJ2WRk9r+/Yem2Et/4/DRrrKYa3v7V8MEvYccC/7XENDjn3zDk9NjNS0RERESOGB1Ss6EpBoOBLl3Ux/1QS05OBqC6ujrGMxHp/F5aspO/fryB4uoGAHpkJjH32gmkJ1l8Y3pm2oKCDWlJnShLYOlT8MGd4Hb5r/WfCqf/BbI7cV0JERERETmsRLMObfVv03fffTcFBQVMmzaNqVOnkpenfcIdyftF1jYKkebtLq3h7rd+wO32nCeYjfzjJ8cEBRrAE4AIZDAYOmqKTXO7YcHD8On9/mtZ/eCUP8KgU6AzzFFEREREjhjRrENbHWwoKSnhmWee4ZlnngFg+PDhTJs2jWnTpjFlyhRtoTjEMjMzASgqKorxTEQ6l+U7Sqizu5jYPxuDwcCiLcW+QENuaiLPXzmOIfmhP5/yOtu2CXstvPcLWPWi/9rEn8PUe8GcGLt5iYiIiMgRK5p1qLG1D3n88cfZtGkTTzzxBBdccAH79u3j0Ucf5cwzzyQrK4sJEyZwzz338MUXX7T2EdKMbt26AbB3794Yz0Sk81i9p5zz/vUNFz29hG+2FAOwZKt/a8Q/LzombKABCMl0iKmKffCf04IDDdN/CzP+T4EGEREREYmZaNahrc5sMBgMDBgwgAEDBnDttdficrn47rvv+PTTT/n000/56quvWLx4Mb///e9xe/+sKO0mOzsbgNLS0hjPRKTzuO/t1b7jR+ZvYuKAHBZv9QQdEs1Gju6R3uR7E8ytjr22r33fwcs/hoo9nnNzEpz9Txh+XmznJSIiIiJHvGjWoe1WAc1gMJCcnIzNZsNms5GQkKB6AodQVlYW4PkiOxwOzOZOVMxOJEb2lNX6jtOSzOwtq/VdG90rg0Szqcn3doqg6Lp34Y2rwX7wZ2d6T/jx/yB/eGznJSIiIiJCdOvQNq1Q9+3b58tkmD9/Prt37wagf//+zJ49m2nTpnHSSSe15RHShNzcXAwGAy6Xi+LiYhXoFAEKKup9x72yklmzt8J3PrpXZrPvLTnYqSJmvv0PvHsrcDDo0WMsXPgipOp7W0REREQ6h2jWoa0ONtx666088sgjvgd6i0NOmzaNPn36tPa2EiGTyUSXLl0oLCxk7969CjbIEc/pCs5MSEowsm6fP9gwrFvzRWv3ldcFnTc4XB23tWLlf+HdW/znI2bDmX8HSycrWikiIiIiR7Ro1qGtDjYUF3v2Qfft25frr7+ek08+maOPPhqjsZPsez4CdOvWjcLCQgoKCmI9FZGY21USvG3L5Q7OVuiekdT4LUGKquqDzg9U1bf4njZzueDz38PXf/Ffm/hzOPkBtbUUERERkU4p0nVoq4MN119/PVlZWXz66afceeedAOTk5DB16lSmTZvG9OnT6devX2tvLxHIz88H1JFCjgwLNhXx2vJdDO+ezlUnhP5s2VZUHXRud7ioqLP7zlOtzf+4O1AZHGwoqKg7tMEGRwO8fiWse8d/bfz1CjSIiIiISKcW6Tq01cGGCRMmMGHCBAAKCgr47LPPfPUbXnnlFQD69OnD9OnTeeqpp1r7GGmG94uszAY5nNU0OLjxpZV8tr4QgLdW7eWc0d3JTgluAbm5sCrovN7hIrDmo7GFBfyBRpkNhRX1TYxsB047vHY5rH/Xc24wwcn3w4SfKdAgIiIiIp1apOvQdtnzkJeXx49//GOefvpp1q1bx1NPPUWPHj3Yvn07Tz/9dHs8QsLwth3xbmkROVw4XW5fd4gFm4p8gQavREtoV4m1AfUZABwuN5V1Dt95SmLzsdXG2ygKK+uaGNlGDdXwv5/4Aw1mK/zkFZh4owINIiIiItLpRboObXO/RKfTyYoVK3wdKRYuXEhdneeXdJvNxgknnNDWR0gT0tPTAaioqGhhpEj82FhQyU+eWkLXdCuvXjcBQ6MFeI/MJFISzWwurOKfn29myqAunD26O5sKK0PuVe9w+o6tCU23vQQorbYHnTfeVtEuqgrhpQth7wrPuSkRfvQSDJjW/s8SERERETkEIl2HtjrY8N577/HMM8/w+eefU1ZW5rmZ2cz48eN9XSnGjx9PYmJi8zeSVrPZbADU1NS0MFIkfvzm7TUUVdVTVFXP3GW7GJKfGvT6sG5pVNTZ+el/lrK7tJY3V+4hw2Zhd2lt0DiTEWoa/MGGpDDZEF5ut5sGhyvoWuNMhzYr2QYvnAOl2zzniWmeQENfBWRFREREJH5Eug5tdbBh7ty5vPnmm4waNcoXXDjhhBNISUlp7S0lSsnJyQBUV1e3MFIkfnyz1Z+OtXBzEcf1yw56fVi3dH77zpqg4MLtr35HWU1wZoLD6aa63rONwmoxYjE1vWvMYDBw3ZR+PPbZZt81u9Pd5PiolW6H52ZCxR7PeVp3uOhVyBvWfs8QEREREekAka5DWx1suP3223n44YfJyclp7S2kjRRskMON2+0m0Wyk/mCWwYaCSrKSE4LGmIwG3lixJ+haUVUDjTU4XJTXegIQaVZLi8++bcZgzhjZjce/2MK2omouOa53az9GsIq98PxZ/kBDlyFw8RuQ3r197i8iIiIi0oEOebDh6KOPbu1bpZ1oG4Ucbg5U1vsCDQA7imvYVx68PcJiiqyIot3lz2xIbqE4pNfAvFT+duGoyCYbicL18N/zoGK35zxnEFz2LqR0ab9niIiIiIh0oEjXoW3uRrFu3Tp+97vfMWPGDCZMmEBRURHgiXLMmTOH5cuXt/UR0gQFG+Rw07ijBMCr3+4OOg9sYXls78wm71Vd76DiYDeKtKSWMxva3e7l8Owp/kBDZh+49G0FGkREREQkrh3ymg0A999/P7/5zW+Crtntdt8EHn30UZKSkli4cGFbHiNNSEpKAqC2traFkSLxYVtRaCrWC4t3BJ2X1vi3TIzpncm3O0rD3mt/ub91Zaatg4MNWz6HuRdDQ5XnvOtIuOg1SMnt2HmIiIiIiLSzSNehrc5s+OKLL/jNb37D8ccfz5IlS3j33XeDXjcYDFxwwQUsXrxYrRkPEdVskMPN2r3+nxUDcsMXm90XEEQY3y+ryXsVVvrHZXRkZsPqN+DFC/yBhj4nwE/fU6BBRERERA4Lka5DWx1s+Ne//kV+fj7vvfce48aNIyEhIWTMqFGjcLlcbNiwobWPkWakpnpaAlZVVcV4JiLtIzCz4U/njQg7Zk9AF4ruGTZyUvw/e7KSE3w1HQKLRmYmh/58OiTWzYPXrgDXwc4Yg2d6uk4kpjb/PhERERGROBHpOrTVwYbly5czZcoU0tPTAU8mQ2Pe15TZcGh401dUs0EOB263m40FlQB0TbcypncWU4eEZgMEtrxMNBuD6jHkpiZiSwjdHZZp64BgQ+F6eONa4GDLzNGXwOznwZJ06J8tIiIiItJBIl2HtjrYkJCQ0OIejW3btgGQkZHR2sdIM7xf5Pr6elwuVwujRTq3gop6X0HHwfmeaOmD543govG9GBiwpWJPmf/nji3BRHFABkNOSiIpYTpPHPKaDVWFMPcisB/MzBhxAZz5dzC1qSyOiIiIiEinE+k6tNXBhsmTJ/PVV1/5uk80zmxwu908//zz5OfnM3LkyNY+RpoRuHXFW5hTJF7tKPZvoeiT7dkHlptq5ffnjOC6Kf3DvsdiMlJe6/+3n5uaSHqY+gzZKYntPNsANSXw/FlQvNlznjcczngMwmR7iYiIiIjEu0jXoa0ONlx77bWUlZVx1llnsWnTpqBgw759+/j5z3/Oxx9/zCWXXILZrL/uHQomk8l37HQ6YzgTkbbbHhRssAW9lp9uDfuepART0HmXtESywtRnyE09RMGGhhp46UIoXOs5T+8JP3oJEmzNv09EREREJE5Fug5tdRRg9OjRPPDAA9x7770MGjSI7OxsAE4++WTWr1+P0+lk7Nix3Hfffa19hLQgXJ0MkXi1s8S/56t3TnLQa3lp4YMNjb8FKmodQQUjAY7plcHRPTLaZY5B3G6YdxPsXuo5T86FS9+GzN7t/ywRERERkU4i0nVoqzMbAO655x4+++wzLrnkEl/6xJo1axg9ejSPPfYYX375JSkp4dvXSdu53e6wxyLxaHuRP9jQNzs42NAjMykksJBkMbFmb3Dx2d2lNVx0XG+6ZyQxrk8WT116LK9dN5EEc5t+1IVyu+GjX8MPr3rOE1Lg4tchO/x2DxERERGRw0Wk69A272846aSTOOmkk3C73VRWVmK1WoP2cNTV1WG1hv+rpLRN4BfWaGznxZRIB9td6gk2GAzQPTO4g4PVYiInJZEDlfW+a5k2C2v2lAeNW7mzjLF9slh419RDO9mlT8Lixw+eGODsx6Hr0Yf2mSIiIiIinUCk69B2W6EaDAbS0tJ8gYb6+nr++c9/MmDAgPZ6hDQSWPlTWyok3nm7TOSmJmIxhf5o6tqobkOGLYFejTIg6uxOXK5DnOXjcsKCv/nPz/w7DD3r0D5TRERERKSTiHQd2qpgQ2lpKV988QXffvttSPvLhoYG/vWvfzFgwABuvPFG9u7d25pHSAQCi3GoCKfEI4fTRZ3dSWWdnaKDLSxzU8NnQjUONmQlJzBlUBf+fckYsg8WheydbcNoPMSBt52LoXKf53jgKXDMJYf2eSIiIiIinUik69CoVqj19fXcdNNNzJkzh/p6TzpzTk4Ozz77LGeccQZffvklV111FZs3b8ZoNHLRRRdxzz33tPIjSEu8XwOj0RhUEVQkHizYVMTPXloR1LoSoNYevqJtt4zgrRXj+2YBcMqwfCYNyGHJtmJGHopCkI2tecN/PPy8Q/88EREREZFOJNJ1aFSZDQ888ABPPvkkTqeTkSNHMmTIEIqKipg9ezYvv/wy06dPZ/PmzfzkJz9h7dq1/Pe//2XIkCFt+yTSpLq6OgASExO1jULizguLt4cEGgASwmyhAJh+VB4GAySYjdwz8yh+dpJ/i1ZyopmpQ/LITjlELS69akvh+4NFIc1JMPi0Q/s8EREREZFOJtJ1aFSZDS+//DLp6eksXLiQYcOGAfD+++8zc+ZMLrroIvLy8njjjTeYMGFCG6YukfJ2ALFYLDGeiUjLGhwuzEaDb5vD3rK6sOMumxi+deTxA3L46o6TSLWaybAlhB1zSDka4JVLof5gUcphZ4M1rePnISIiIiISQ5GuQyMONuzdu5etW7dy8803+wINAKeffjrTp09n/vz5PPPMMwo0dCDvFzmw+4dIZ7NgUxF3v/UDO4prGNcni5euHo/ZZGRfuSfYkJ9mZcEvT+LV5bspr7VzzugeTd6rZ5ato6YdzO2Gd2+FbV95zpOyYMovYzMXEREREZEYinQdGnGwoaSkBCBsd4kBAwYwf/58TjjhhGjmKG3U0OApqKdgg3RW+8prufiZJb7zZTs8P0fsThfF1Z69XnnpVswmIz8e1ysmc4zIkidg1X89x2Yr/OQVyOob2zmJiIiIiMRApOvQiGs2eHtphkuV8D4kOTk55DU5dLx7ZZKSkloYKRIblXWOoPPJA7tgNhkpqKjD2543P+0Q11loqx2L4OOAQrdnPw49x8ZuPiIiIiIiMRTpOjTqfokNDQ3U1NQEXfOmUdTU1GA0hsYvbLaOTX1evHgx33zzDQDXX389Vmv4VnrLli3j6aefpqSkhIEDB3LTTTeRn5/f5H1LSkr4+9//zurVq0lLS+Oyyy5j8uTJTY53uVy89tprzJs3D7vdzsSJE7nmmmuanE+0SktLAUhL075x6ZyykoOjnfedMRSAggp/vYau6Z04WFa+G+ZeAq6DQZPjb1EHChERERE5okW6Do062HDTTTdx0003hX0tNTU17HVvVkRHKCkp4ZxzzmH//v0AXH755SGLe6fTyZVXXsmcOXNISkqiW7duvP766zzyyCP8/e9/58orrwy57+uvv84VV1xBRUUF/fr1o7CwkGeffZYzzzyTV155hcTE4L/OFhQUcNppp7Fy5Uqys7NJSkpi7ty5PPTQQ7z99tuMGTOmzZ+1oqICgIyMjDbfS+RQ2FFcHXTeJ9uT/VRYUe+7lttZMxvstZ5AQ02R57zfiTD13phOSUREREQk1iJdh0a8jcJisdC7d+9W/V9Huu2223A6nc1mKDz66KPMmTOHadOmsXXrVjZv3syiRYvIysri2muvZfXq1UHjd+3axcUXX4zJZOLjjz9my5Yt7Ny5k/POO4933nmH3/72tyHPuPLKK1m5ciW33347e/bsYefOnTz77LPs37+f8847z9ebtC3KysoASE9Pb/O9RCK1q6SGlTtLcblaDiKW1QS3ttxTWgtAUZX/33/OoW5X2Vrv3wF7V3iOM3rB+f8BU9TxWRERERGRw0qk69CIgw1Dhgxh+/btrfq/jvLBBx8wZ84cHnvssSY/uNvt5m9/+xtGo5EXX3zRF5Q47rjj+NOf/oTT6eSxxx4Les+///1v6urquPvuuzn55JMByMzM5Pnnnyc1NZW///3vviIZAJs2beK9997j6KOP5qGHHvL1H7388su57LLL2LFjB2+++WabP29Rkecvrjk5OW2+l0gkCirqmPbwl5zz+CJOe/Rr3l61p9nMpdJGwYYdJZ5Mh8AgRGYs2li2ZPkcWPmC59higx+9DLas2M5JRERERKQTiHQdetj8ma6iooJrrrmGmTNncuGFF4bNNgDYsWMHu3fvZvLkyeTl5QW9NmvWLMxmM19//XXQde/5ueeeG3TdZrNx6qmn8uqrr7Jq1SrGjRsXMt5gMAS959xzz+XZZ5/l66+/5kc/+lHYOd59992Ap+BGWloaVqsVi8VCcnIyaWlp9OnThyFDhvj2ymRlaREkHWPFjlIaHC4ANhRUcvP/VlFd7+Qn48N3kiiraQg6315UzQkDu1Be6w82pFk72Y+h/avhgzv957MegfzhMZuOiIiIiEhnEuk6tJP9lt96v/zlLykrK+Pxxx8PWeAHWrhwIYAvMBAoPT2dIUOGsHr1aoqKisjJyaGhoYGlS5fSpUsX+vYNbXU3btw4Xn31VRYuXOi7Z3PPaDwmnAcffBCXy9Xk65dddhnPPfccxcXFgIIN0nECCzt6fbO1uMlgQ2njYEOxp7hscbX/ek5qJ9pGUV8Fr/4UHAc/59irYOSFMZ2SiIiIiEhnEuk6NOJtFJ3Z559/zhNPPMEf//hHevUKv+jx2rp1KwDZ2dlhX/de927/2L9/P3V1dS2O9963pWdkZmaGjA/kdrubDTSAv+qnd6+Mgg3SUQoqQ2uN7GxUBDJQSXXwNoqdJZ5gQ2DGQ0ZSaDvdmHA54Y2roXiT5zz/aJjx+9jOSURERESkk4l0HRr3wYbq6mquuuoqJkyYwPXXXx/ReGi6cqY3GOAdF+34lt5jNptJS0sLGh/I6XQ2/wGA5OTkoOd0dGtROXIFdpHw8gYQvAILRxZXBY/fVuT5N1tyMLPBYICMzlKzYf5vYMP7nuPEdE9BSEv7tKkVERERETlcRLoOjfttFPfccw+7du3inXfewWQytTje26KypqYm7Ove/+G846Id39J73G43NTU1Ia0yA1188cU4HA5qamqorKykrq4Oh8NBeXk51dXVdO/eHfC01wQViJSOE5iR0L9LMlsOVFNaY6eyzk6q1cITX27hrx9v4OLjenPfrKG+oILXtqJqKursfLe7HAAD4HC5MBlb/t49pMr3wOJ/eY4NJpj9HOQMiOmUREREREQ6o0jXoXEdbFi/fj2PPvoos2fPpra2lm+//db3Wm2tp8XeypUrSU1NZeTIkVgsFnJzcwH/PpPGvNe947z/A0Y6PvA43HsqKipwOBy+gEFjZrOZF154oYlP7OHdZuH9Inft2rXZ8SLtpbLe4Ts+qmsaWw54gm17y+rIT4O/fbIRu9PNfxZuZ3SvTAobbbtwutyc9OcvfOcJZiPNNLPoOIsfB9fBz3b8TdB/amznIyIiIiLSSUW6Do3rYENhYSFut5u5c+cyd+7csGOmTvUsGgoKCsjNzeW4444DPO0pG3M4HGzbti2oGGRaWhrDhg1jw4YNVFRU+OoleHnv472v9/iNN95g06ZNTJs2rcXx0TIajTQ0NPhajjTuqiFyqFTWeRbkFpOBvjnJvut7y2pZur2Eeoe/3si87/ZSWBlaUNJbHNKWYOKxH43GaolxVkNtKSx/znNsSoTjbojpdEREREREOqto1qFxHWwYOHAgTz75ZNjX7r33XgoKCnjkkUew2WykpqYCMHLkSJKTk/noo49oaGggIcG/X3zhwoWUlpZy9tlnB3W0OP7441mzZg0ffvghs2fP9l13u93MmzcPg8HAhAkTgsYDzJs3j+uuuy5oXvPmzQsa01rFxcW43W4MBgNdunRp071EIlV6MFCQaUuga3qS7/qeslreWbUnaOy2omrq7E0XO33msrFM6B++8GqHWvY0NFR5jkdfBCm5zY8XERERETlCRbMOjesCkV27duXqq68O+3/e4oyXXXYZV199NUlJnoWR2WzmwgsvpKKigoceegj3wRzumpoafv97T+X5iy66KOg53vOHHnqI8vJy3/VnnnmGHTt2MHPmzKBikOPGjWPAgAF89NFHfPnll77rO3fu5N///jeJiYmce+65bfrshYWFgKfjhdEY119GiRMOp4vqg9soUqxmumf6gw2frC1g2fbSoPGbC6t8xycODv5BdFTXtM4RaKivgm8e9xwbjDDxptjOR0RERESkE4tmHRrXmQ2t9Yc//IH58+dz77338sUXXzBq1CjefvttNm/ezDnnnBMSCJg8eTLXXHMNTz75JMOGDePCCy9k06ZNzJs3j+zsbB599NGg8WazmaeeeooZM2YwdepULrroItLT03nuueeoqqrisccea7JmQ6QOHDgAaAuFHFput5vfzVvLu9/vo7i63ldfwWo2kZ/m79Tw5cYDzd7n6O7pfLHBP2bKoE6SjbPsKagt8RwPPx+y+sZ2PiIiIiIinVg069DD9k/iEyZMYNq0aZjNofGUvLw8Vq1axT333MMPP/zAI488gsVi4fnnn+fVV18NG6F54okneP311+nSpQuPPfYYCxcu5NZbb2Xt2rX069cvZPyJJ57I6tWrufDCC3nzzTd56qmnGDt2LF9//TU///nP2/z5vEU5AgtTirS373aX89yi7RRV1QcVcky0RPejo2tGUtD58QM6Q1ZDJSz6+8ETA0y5M6bTERERERHp7KJZhx62mQ3/+c9/mn09MzOTBx54gAceeMC356Q5BoOBc889l3PPPTei8QCDBg3ipZdeAoj4PZHypq8os0HaS53dyVNfbeXlpTsZ3y+bh2ePZN2+irBjUxLNPLdoW8j1TJuF0hp7yPVuGUl0z0hiT5mnS0xgccmYcDnhnZ9DzcGOMcPPg5yBsZ2TiIiIiEgnF8069LDNbIhGtEGA1gQN2jPQAJ4WmgDp6entel85cl3+n2X89ZON7C2v482VeyivtbN2b/hgQ0WtPaSLxPYHZ7LyvhmcMzp0i1C/nGTmXDGWSQNyuH3GIHpk2g7JZ4iIy+UJNKx503NuSoQTfxW7+YiIiIiIxIlo1qEKNsQpb6HKxq04RVrD7XbzzdZi33lKopn0JAvbiqp91wKLPH63u5xbTx5EVrKnm0v3gG0S6UmWoHubjQa6ZSQxIDeV/141nhunxjiD4Is/wKoXPcdGM8x+HnIGxHZOIiIiIiJxIJp1qIINcaqyshJQZoO0j8aZN7OP7YnBYGBDgeffWYbNwh/OGRE0Js1q4dPbpnDvrKE8d/lY3/VUa/DurB6ZSZiM7ZvZ02pLn4Kv/nzwxADnPwuDT43plERERERE4kU061AFG+KUN6KUmpoa45nI4eBAZX3QuS3BRFW9w3d9UG4q3TKSuGW6JyvhiuM9XRsykxO4clJfBub5/x1mH8x28OqdHeP6DF6l2+GjX/vPT/0jDD0rZtMREREREYk30axDD9sCkYc77xc5IyMjthORw8Kmwsqg8wWbizhhYI7vvE+Op8bCLdMHcdPUgTRXgiTdFryNIubFIL0+uhucDZ7jcdfCcdfHdj4iIiIiInEmmnWoMhvilPeLrG0U0hoOp4tNBZW4XJ5+loUVwZkNq3aVceGTi33nx/bO8h0bjYZmC55m2oIzG04f0bU9ptw2a9+B9e96jpNzYeo9sZ2PiIiIiEgcimYdqmBDnKqu9hTuS07uJH81lrhy79urOflvX3HZf5bidLnZX1HX5NhMm4UzR3WL+N7j+maRn2YlwWzkj+eOYFzfrJbfdChtXwBvXuc/P/WPYFVhVRERERGRaEWzDtU2ijjV0OBJB09ISGhhpEgwt9vNy0t3AfD1piLmLtvFvrJa3+s5KYnkpiaSaDGSarVwzQn9QtpcNseWYOarO0+iut5BZnKM/31u+QxeutC/feKoM2H4ebGdk4iIiIhInIpmHapgQ5yqr/ekvScmJsZ4JhJvChsVg1y2vYTKOofvfN7Pj6drelLjt0UlwWwkwRzjQIO9Fubd7A80DJwB5z5FswUnRERERESkSdGsQxVsiFPaRiGtteVAVdB5Ra2dfeWebRRmo4HcVGssptX+FvwNynZ6jnsfDz96CUyW5t8jIiIiIiJN0jaKI0BdnWdxaLUeJgtD6TDbi2qCzh0uN7tKPde6ZlgxGeP8L/9uN6x6Eb76i+fcaIaZf1WgQURERESkjaJZhyrYEKcUbJDW2l5cHXS+t6zWt42iV5YtFlNqP3UV8PKPYMdC/7VJt0LuUbGbk4iIiIjIYULBhsOcw+HA4fAsDpOS2ra3Xo4M877by0MfrWdE93S+2lgU9NqmQv+2ij7Zcb4tZ8HDwYGGERfAlF/Gbj4iIiIiIoeJaNehCjbEIbvd7ju2WJQaLi17+uut7CqpZVdJbbPj4jqzoXw3LH7Cf37hi3DUrNjNR0RERETkMBLtOtR4KCcjh4bL5fIdG436EkrLGpzuiMb1jOdgw2e/B8fBYMpxP1OgQURERESkHUW7DlVmQ5wzqI2fRMAcYdHHHplxuC3H7YYlT8B3L3nOrekw5Y7YzklERERE5DAWyTpUwYY453ZH9hdrObKZTZEFG3pnxVnNBkc9vH87rHjef23KLyEpM3ZzEhERERE5zEWyDlWwIQ4FpqwEprKINCXJYmpxTHZyAum2OKoBUlMCL82G3cv81074BYy/PnZzEhERERE5TEW7DlWwIQ4Fpqwos0EiYUtoOdgwtFtaB8yknbhcnhaX3kCD2Qpn/gOOviC28xIREREROUxFuw5VsCEOBUaUnE5nDGci8SIpoeVv9Z+dNKADZtJO1r4Fu5Z4jpNz4eLXoOvImE5JRERERORwFu06VMGGOGQ2+79s3j6nIs3JSAq/PSI10cxRXdP47ZnD4iezwWmHzx7wn5/9uAINIiIiIiKHWLTrUAUb4pDRaMRgMOB2uxVskIikJYX/Vn/kR6OYdlReB8+mjb75J5Rs9Rz3ngQDpsd2PiIiIiIiR4Bo16EtN8eUTsli8fylWsEGiYStiW0UO4prOngmbbTmTZj/W//5jPtB7V9FRERERDpENOtQBRvilPeLbLfbYzwTiQeWgNaXfXOSsSWYSLKYOKZ3HLWIXPkivH41cLAYzaTboPuYmE5JRERERORIEs06VNso4lRiYiLV1dXU19fHeirSydU2BBdvuWX6QE4dnk+9w0WaNU5aXX7xJ/jiD/7z0RfDtPtiNx8RERERkSNQNOtQBRviVGJiIgB1dXUxnol0VmU1Dfzpw/XMXbYLV0Bnmup6J4lmE4nmltthdgobPwoONIy9Ck79k7ZPiIiIiIh0sGjWoQo2xKmEhAQAGhoaYjwT6ax++p9lrNpVFnK9uCqOsmFcruDOE1Pvhcm3x24+IiIiIiJHsGjWoarZEKdsNhsAtbW1MZ6JdEZut5u1eyvCvlZeG0d1Pn54Ffb/4DnuOhJO+EVs5yMiIiIicgSLZh2qYEOc8n6Ra2rirJuAdAiDwUBWckLY1+odrg6eTSs5GuDz//OfT/+dtk6IiIiIiMRQNOtQBRvilIIN0pJau78wZF5aou/Y7oyTYMOq/0LZTs9xv5Og/0mxnY+IiIiIyBFOwYYjQGpqKgCVlZUxnol0VoHbJY7p5W9xWVoTB3U+HPXw1V/951Pvjd1cREREREQEiG4dqmBDnEpJSQGgqqoqxjOReDCsW5rvOC5qNqx4Hip2e44HngI9xsR2PiIiIiIiEtU6VMGGOJWUlASoQOThwuVy43a7Wx7YSvnpSb7jTl+zYecS+Ohu//nkO2I3FxERERER8YlmHapgQ5yyWq1AZP1NpXPbWVzD8X/6jNMe/ZrqescheUaX1EQSzZ5v95p6ZwujY6h8D/zvJ+A82J5z9CXQc2xs5yQiIiIiIkB061AFG+KUMhsOH3/6aD37yutYv7+Sf32xpV3u2dAoe8FiMpBp83SnKK7uxDUbPv0d1BR5jvtOhll/i+18RERERETER5kNRwDvXpnq6uoYz0Taatm2Et/xpsKmC60s3lrMu9/vxeVqfruF2+3mzx+tD7p2oLKetCQzwCHLnmizgjXw/Sue46RMuGAOmCyxnZOIiIiIiPhEsw41H+rJyKHhrQJaUVER45lIWxVW1vuO++akhLxe2+DkxpdW8On6QgD+coGL88f0CHuvqnoHf3x/HS8u2Rl0vaS6AYvJE1t0uDppzYZPHwAOBlIm3Qa2rJhOR0REREREgkWzDlWwIU4lJycDymw43BzVNTXk2r+/2uILNIAnSyGcdfsqmP3vb6isC81cqKpzYDIaAHC2kBkREzuXwMYPPMep3WDc1bGdj4iIiIiIhIhmHaptFHHK+0VW68vDi9Pl5ta5q3jqq62+ugt7y4L3Q/XNsYV975xF24MCDT8a29N3XFFn9wUbXG5a3IrR4T57wH984i/BktT0WBERERERiYlo1qEKNsSpnJwcAAoLC1sYKfHk5aU7eXPlHn7//jpm/O1LdpfW4Gy062FAbuhWC5fLHZT98OYNE7n8+L6+8/Jau68bBXSy9pfbvobtX3uOs/rDqItjOx8REREREQkrmnWogg1xKj8/H4ADBw7EeCbSFm53cIZBg9N/vr24hqe+2oq9UbShd3ZyyH2+3VHq214x/ag8RvfKJDPZX1zxQGU9VovJd15n7yTtL+urYN7N/vMpvwSTdneJiIiIiHRG0axDFWyIU97CHJWVTXcvkM6vcYZBmjV4oV1U3UBNg39rRIbN4iv0GGjed3t9xzOP9vwA6JKS6Mtm2FlSE5TZ0NA4XSJWPvo1lBxs99ltNIw4P7bzERERERGRJkWzDlWwIU5598rU1NTEeCYSLbfbzebCSmoaHFTU2oNeSwrIPgBPm8rNhf79UEflp4Xcz+ly88Hq/QAkmo2cPNQTbDAYDHRNtwKdNLNh7TuwYo7n2JIM5z0DRlPz7xERERERkZiJZh2qfOU4ZbN5igTa7XbsdjsWi6WFd0hn8a8vt/DQhxvItFk4fUTXoNfSk4K/jpV1DrYX+7+Rj+oaGmxYsrWYoirPFooTB3chJdH/be29X2W9vxsF4Cs+GTOVBcHbJ057ELL7x24+IiIiIiLSomjWocpsiFPe9BXQVop488EPniyE0ho7Ly7ZGfRaVkpC0Hl1fXAby5E900Put2avv8etN6vBd79kz/3cbk/7Sy9HLLtRuN3w9s+gtsRzftQZMPqS2M1HREREREQiEs06VMGGOGWxWEhK8rQHrKioaGG0dBYulztoW0RjFmPwt2R1Q6NgQ4+MkPfsCWiN2Ts7uC1mps0fvKgKCFw4nDEMNix5AjZ/4jlOzoVZj4DB0OxbREREREQk9qJZhyrYEMfS0z1/5S4rK4vtRCRie8pqqW2mXkJSQnDNgrKa4JoOyYmhO5+2F1f7jntmBgcbMgKCDRV1/ns53TEKNuz/AT65z39+zr8gOSc2cxERERERkahFug5VsCGOZWRkAAo2xJMtB5rOagCC6i2Ap2ZDIFeYIMGG/Z70pTSrmby0xKDXMm3+PVTV9f4gR+N2mh3CXgevXwXOBs/5cT+DAdM7fh4iIiIiItJqka5DFWyIYykpKQBUVTW/gJXOY8uB6mZfD9fWMlDjWgv1Dif7K+oA6JuTjKHRdoT0gGBD4DaKmAQbPnsADqz3HOeNgOm/6fg5iIiIiIhIm0S6DlWwIY5598rU1dXFeCYSqa0tZDa0EGvA3qiLxK6SGrzJDr2zk0PGB26jKA/YkmGgg2sk7F4O3/zTc2xKhHOfBHNi8+8REREREZFOJ9J1qIINcczb41SZDfFjW5E/s6FrujXk9aSE5rvRNs5I2F7kb4vZp1FxSAjeRtEQi2wGAJcT3rsVOBgVmXo35A2NzVxERERERKRNIl2HKtgQx7KzswE4cOBAjGci4VTXO/hw9f6gjAJvsCHDZsHWqBgkeOouNKe+UWZDYHHIcJkNgd0oArnpwAKRq1+Hfd95jnOHeWo1iIiIiIhIXIp0Hdr8ykY6Ne8XubS0NMYzkXDufXs1b6zYQ15aIq9fP5GclET2lXtSjfpkJ1NYEZp2ZDY2H/+rdwR3sthRHJDZkBOa2dC4u4VXh22jaKiBTx/wn5/yezDpx46IiIiISLyKdB2qzIY4pgKRndvHawoAKKio5w/vr2N3qT8w0DvbFnZbg9nUfBCgtqHpzIY+YTIbUsO0ygQwGTso2LDgYSjf6TnuPxX6ndgxzxURERERkUNCBSKPAKmpqQBUVFTEeCYSTmD3h6XbStldWus775GZREOjLRFGAyS3ULOhuiG4FebWg90t0qxmspJDt0ykJVlCrkEHBRuKNsPCRz3HRguc+icwdHBhShERERERaVeRrkMVbIhjWVlZAJSUlMR4JtKYo1HWQlFVvS8wAJCVnEhNQ/CWCIPBQFZK+BoLXnV2/3tqGhzsK/cEMHpnh7a9BEg0GwkXV7C0kEHRLj78JTgbPMcTb4Qugw79M0VERERE5JCKdB2qYEMcy83NBaCwsDDGM5HGSgOKQnptLKj0HdfUO3C4gos0utxussNkJwSqDQhQrN1bgfcWw7qlhR1vMBhIsoTWbUgwH+Jv/Q0fwub5nuO0HjD5jkP7PBERERER6RCRrkMVbIhj3sIcymzofArCFH9ctavMd1xS0xDyutvtyURoLhAQmA2xfr8/eDG0iWADgDVMsCFcAKLdVBfDvJv95zPuh4TQehIiIiIiIhJ/Il2HKtgQxyLtbyod70BVfci1wOBAVZ0j5HXwZCI01/6yNmAbxYaA+w3JjzLY0ESXijZzu2HeTVC133PefyoMO/fQPEtERERERDpcpOtQBRviWEKCJ+W+oSH0r+QSW00FE7wa12vwcrvdJJqbDgTUBBSIDOxE0b9L05kDtjCBhdTE8IUj2+z7ubD+3YMPzoaz/6WikCIiIiIih5FI16EKNsQxq9UKQH196F/RJTbcbjdut5uyMNskAosyVtaHD0bU2V3Ntr8sqfbXgthS6IkkpjbRicKrcbDBbDRgtRyCb/2KvfDBnf7zMx6F1Pz2f46IiIiIiMRMpOvQ5vvsSafm/SLX1YXWB5COVVBRxyPzN/LWyr2cPDSPIV1TQ8bkpCSyr9zztaqqCy0gCZ52mc3lAVTUet5XWWdn78F7DclPDduJwiux0TaKFKu52fGt4nbDu7dBXbnnfMRsOOqM9n2GiIiIiIjEXKTrUAUb4pg3fcXhcOByuTAalagSC6v3lHPhv7+h+uDWiHe+20tWcp+QcelJFl+woSxMtwoI3iYRTsXBIEVRlT9zomt6UrPvSTAF/7tISTwE3/bfPgsbP/AcJ+fCaX9q/2eIiIiIiEjMRboOPWyCDQcOHGD16tVUVlbSo0cPRo0a1eLi2+VysWTJEkpKShgwYACDBw9u8Tnbtm1j7dq1pKWlMWHCBMzm5v8nrKqqYsmSJdjtdkaPHk1eXl5Un6s5Fot/373D4fB90aVjfbK2wBdo8AoXNEgNKPxY0URNh8o6R9iaDQaDJ3nAm9lQGrBNI9PWfP0FkzE4i6Hdgw1lO+Hje/znZzwKtqz2fYaIiIiIiHQKka5D4/5P4f/73/849thjyc3NZerUqZx11lmMGTOGnj178vDDD+N2u8O+7+OPP2bUqFFMnDiRWbNmMWTIEM477zy2bdsWdvy+ffu49NJL6d+/P7NmzWLy5MkMHTqUN954I+x4t9vNY489Rr9+/Zg+fTqnnXYaffr04Y477qC6ujrse6IVGExxuVztck+JntMV/G8sJdEcEnwASLP6vymLwnSrAKiud4TUU0g0G8lI8rzX2zKzJCCzIcPWfJCpcbAhLamdi0N+ch/YazzHx14BQ05v3/uLiIiIiEinEek6NO6DDa+++iqbNm3iiiuu4JlnnuGVV17h17/+NRUVFfziF7/gscceC3nPN998w8yZM9m+fTuPPfYYX3/9NTfccANvvPEG06dPp7KyMmi83W7n9NNP54UXXuCiiy7iq6++4umnn6asrIzzzjuP9957L+QZf/nLX7j55pvJyMjg9ddf55NPPuG4447jL3/5C1deeWW7fHaTyf8XcAUbOo/slAQqw2QutBQUAE/GQ4I5+NsyLclCTkoiAAcq63G73ewtr/W93j2z+W0Uxkb1GVrKhIjK7m9hzZue4+QuMP237XdvERERERHpdCJdh8b9NoobbriBOXPmkJKS4rt2wQUXMHPmTCZNmsRDDz3EDTfcEJTqcdddd+FwOHj77bc56aSTAJg0aRIpKSk89NBD/POf/+Suu+7yjX/hhRdYtWoVl112Gc899xwAJ5xwAuPHj2fEiBHcfvvtnH766b6ie2VlZdx///1kZWXxzTffkJ2dDcDUqVOZMGECc+fO5bbbbmPcuHGH+n8e6QCNEgfItCVQGaYAZE5qy8GG6vrQYEN6koUuqYlsKqyizu6ist4RVLOhy8FARKTzS26vbRRutyerwevEX4E1vX3uLSIiIiIicS3uMxumTZsWFGjwmjhxIgMHDmTv3r3s2bPHd72yspIFCxbQp08fTjzxxKD3XHHFFQB88MEHQde9597XvYYPH8748eNZv349O3bs8F1fsGABVVVVnH322b5AA3jSTX7605+GfUZrBEaR2r27gETMZAwNDtSG2UaRGsEiv6LOHpKJkJJoJjfVH1AorKj31W4ASG8hU6HxP4309tpGsepF2LHQc5zVH465tH3uKyIiIiIinVak69C4z2xoitvtpqbGs488Pd3/19bFixfjcrmYMWNGyP8wgwcPpnfv3ixdupSGhgYSEhJwu90sXLgQm83GxIkTQ55zyimnsGTJEhYuXEifPn0AWLjQswCbMWNG2PGBY8K5++67AUhKSiItLQ2r1YrFYiE5OZm0tDQyMjI45phjgr7I6kQROxZz8L+j9CQLO0tqQsZZLSaMBnCFLyMCeApANv53mZ5kITPZnxVRXtsQtE2jpSCGoVEzzYykdigkWrkfPvy1//zUB8HUzrUgRERERESk04l0HXrYBhvmzZvH7t27OfHEE8nMzPRdX7lyJQDdunUL+76uXbuyY8cONmzYwIgRIygsLGTfvn307ds3bOeJrl27+u570UUXtfiMwPFNefDBB1uswbBy5Up69uzpOw/cNyMdq3FryazkBBocoV+/BLORVKuF8trwbS/BU5OhMVuCyVezAaCgoj5om0ZLBR/dBEc3khPb4d/K/N9Bfbnn+OgLYVBoYE1ERERERA4/Tqc/i7u5dehh+efw3bt3c80115CQkMDDDz8c9Fp5uWeBlJUVvjWfd9tDRUVFq8a39J6kpCSSkpKCxgdyu90RFXs0Go1BX2RlNsROoiX4GywnJYH6MMGGRLOxxbaT+8rrcDVKfUg0G8lPs/rOCyvqqA5ordlSDYbGgY82b6MoWAPfvew5tmbAKX9s2/1ERERERCRuRLoOPewyG0pKSjj99NMpKCjgmWeeYfTo0UGve1thNrW3xHvdu+CPdnyk72kqoBD4hWuOxWLBbvf8ddtoNCrYEEO2RsGG9CQLzjBfX7PRSKK5+a9TQUUdtoTgb8tEs4mcgJoNRVUNVNX7/500fn5jDc52DDa43fDhXeDNljjhNkjObvYtIiIiIiJy+Ih0HXpYBRvKyso45ZRT+OGHH3jkkUdCCjoCpKWlAZ6gRDje695x0Y5v6T11dXXU1NQ0mSkBcPHFF+NwOKipqaGyspK6ujocDgfl5eVUV1dTUFAQFGwI7LQhHS/FGvxtlGFLCFuXwWwytFjM8UBlPXnpwUGqBLORbun+zIZdpTWU13i6UaRazRgbt5toxNloMqnWNvx7WfUSbPvKc5zRG8Zd2/p7iYiIiIhI3Il0HXrYBBsqKio49dRT+fbbb3nwwQe5+eabw44bOXIkAPv37w/7+v79+0lISGDw4MEA5Ofn06VLFwoLC3G5XCGRG+99vPf1Hn/yySdhn1FQUBAyPpDZbOaFF15o7qPicDgwGo1s3boVULAh1jIaZQrkBwQGAhkNBjJtzRdnLKlpwNooU8FogC4BmQ2lNXaKqz3BhpwW2l5CaEHK7JRWFogs2gTv3+4/P/WPYAn/WUVERERE5PDkcHi2dLe0Dj0scu8rKys57bTTWLJkCb/97W/55S9/2eTYCRMmYDAY+PTTT0Ne27p1K1u3buXYY4/FavUsogwGA8cffzxVVVUsXbo05D3z588H4Pjjj/dd8x6He0a48dEym80YjUbq6uoAfHOV2MhoFEDIT7OGtJsEMBsNJCU0v+Whzu5iT1lt0DWDwRBU66Gyzk51vecbPNXacrywcWZDXmor/r24XPDmtWA/2GXjmEthyMzo7yMiIiIiInEt0nVo3AcbqqurmTlzJosWLeLuu+/mvvvua3Z8RkYG48aNY+PGjSxevDjoNW9GQeOWld7zOXPmBF3fvHkzCxcupG/fvvTv3993/YQTTsBqtfLGG28EFYJ0u908//zzYZ/RGrW1nkVpUlJSm+8lrZfTKFMgKzl85oAbWqzZAIQUlzQZDZhNRmwHAxWFFfW+bAVbC8ELAEdAsCHBbGxxK0dYa96APcs9xzmDPK0uRURERETkiBPpOjTut1FcffXVfP3113Tv3h2TycTvfve7kDFXXHEFvXr18p3//ve/5+STT+bMM8/kr3/9K8cccwwvv/wyDz74IF27duWmm24Kev/ll1/OI488whNPPIHZbObaa69l48aN3HrrrbhcLh588MGgYpDZ2dnccccdPPDAA5x00kn85S9/IT09nQceeICvvvqKmTNnMmnSpDZ/9vp6T5vExMSWU+nl0Gm8NcKWYApphwmeRX+46y0xH6zJ0CU1kR3FNUGZD42LSYYTWKwyrTX1Gux1nlaXXqc+CAnJ0d9HRERERETiXqTr0LgPNuzYsQOAPXv2cP/994cdc/LJJwcFG6ZNm8Yrr7zCHXfcwaWXXuq7PnXqVB577DEyMzOD3m+1Wvnwww+56aab+Mc//sE//vEPALp27cozzzzD7NmzQ575m9/8BqPRyF//+lemTp0KeHqQXnXVVfz5z39uslNFNKqqqgBISUlp872k9RoXaDQYDGG3UThdLiytCDZ475+XamVHcU3QaxFlNjj9mQ1Zya0INiz5F5Tv9Bz3nwoDpkV/DxEREREROSxEug6N+2DDG2+8QUNDQ7NjcnNzQ66df/75nHnmmcyfP5+SkhIGDRrEuHHjmrxH3759mTdvHqtWrWLNmjWkpaUxffr0JlNHTCYTv/3tb7nxxhv58ssvsdvtjBs3jn79+kX3AZvh/SKnpqa22z0lenZnaJtLU5hog8PpxmqJPtjgOthKNTNMoCCwlkNTKuscvuPcaOs1VB2Arx/2HBuMMOP/onu/iIiIiIgcViJdh8Z9sCEvL6/V701ISOD000+P6j2jRo1i1KhREY/PycnhvPPOi3JmkSkvLweU2RBre0qDCzo6nC4SwtRmcLjcmBtlNmQlJ1BS3XywzHkwMyFcy8pIakAcqKz3HacnRZnZ8NkDUH+w7sjoSyBvWHTvFxERERGRw0qk69C4LxB5JPN+kbOysmI8kyPbrtLgrQ3F1Q1ht0vYnS4a7biIaPHv3QQRrs2lNYJtFA0BmReNi1k2a9dSWOEpaEpCKky9J/L3ioiIiIjIYSnSdaiCDXGsrKwMgLS0tNhO5Ai3r7wu6Hx/eR2mxlEFoMHhIsEUHBxIMBlbzE7wtq7MDtPlItqCk11SIywm2lDtaXXpDXWc+EtICd2OJCIiIiIiR5ZI16EKNsQxb1vN9PT0GM/kyFbQKNiwr7w2bAChzu4M2V6RYG452OB2e7dRhO56Mhuj+xbODpMdEdbH90LJVs9xj7Ew/vqoniMiIiIiIoenSNehCjbEserqagCSk9WGMJYOVNUHne8vryPRErq9oc7uIqlRgUiDAZJbKPLoPBhssIUZZzZF19UkXHZEiF1L4dtnPMcWG5zzbzDFfXkXERERERFpB5GuQxVsiGPFxcUAIa065dDZXlTNzf9byT8+20RVvafLw7ai6qAxe8vrwtZiqLM7Q4IQBoOhxboNdocn2JAcpj6DOcx2jea0WCPC6YB3b/OfT/sNZPeP6hkiIiIiInL4inQdqj9XxrHCwkKgbR05JDqPfrqJt1ftBeDpBdv43ZnD2FMW3I2ipLoBa5jMhhq7E1uYgEFaCwEAb+vLcBkQ4WpDBPLWe/DKbqlA5NJ/Q8EPnuP8ETD2qubHi4iIiIjIESXSdaiCDXGstLQUUGZDR9pUWOk7Lquxc+vcVSFjSqsbwtZXqG1whq3PkNFCsKHe4ekmkdKKYEODwxV0nmFrJthQthM++/3BEwPMekTbJ0REREREJEik61Bto4hjVVVVgLpRdKT9jYpButye/wtUWFmPKUzhxtoGZ8h1l8sdNtshUPXB7RrhxjV+dmN1dmfQeZq1icCG2w3v3gr2g1tCjr0cehzb/M1FREREROSIE+k6VMGGOOV2uzlw4ACgzIaOUu9wUlTV0OK4oqp6Ei2h31qV9XYsjQo6Ol3uFusoNDg92Qm2hNAsg5YqNnjrSng17obhs/p12Dzfc5zaDab/roU7i4iIiIjIkSaadaiCDXGqvr6e2lpPrYAuXbrEeDZHhsZZDU0prKwn3O6G8lo7FlPwt5zT5Sa1qWyDg7zbKMIFJVpIbPAFKppVVQjv3+4/P/3PYFW2jIiIiIiIBItmHapgQ5zythsBtb7sKHvLIgs2OF1uSqpDMyDKauwhmQh2lwtrmCyIQJV1nuyEpARTmMyI5oMJVXWOZl/H7fYEGmo9+64YehYcNav594iIiIiIyBEpmnWogg1xyvtFTkxMxGxWEb+OUFDRfLAhNaCAY+PCjAAVtXYMhuBggd3pIinM9ohA9QF1F5IadbmobWg+2FBRZ2/2dZY8AWvfPnjzLJj5cPPjRURERETkiBXNOlTBhjhVVFQEqF5DRyqqqvcdh9vScFQ3/9aDcIUbq+oduN3BL9Q2uEgwNV95oT4gcNG4/aWjhcyGgor6pl9c+w58+Cv/+RmPQHJOs/cTEREREZEjVzTrUAUb4lRZWRkAWVlZsZ3IESSwOGRuamLI6/27+NOI7GFqJbjcUFITvL2izu4MqePQWHWDfytE444UjhbaUTSZjVG8Bd64Gl/VhxNu92yhEBERERERaUI061AFG+JUZWUlAKmpqTGeyZGjMGDh3jUjKeT1vjn+YIPLHT4IUNgo06DW7sTcQrAhcEuGtdE2isatLRsrqwnTPcPthvduA8fBz3P0j+Cku5u9j4iIiIiISDTrUG32j1Pl5eUAZGRkxHYiR4BdJTXc9soqlm0v9V3LsoVuo+iVZfMd253hgw0HqoKDDU6XO2x9h0A1DU7cbjcGgyEk2FBT33ywoaTaX7NhcH6K52DlC7D1C89xek+Y9TAYFXcUEREREZHmRbMO1QojTnkLc9hsthZGSlu9uGRnUKABQmsnAHRN92c71DeRcRBuW0NNQwsdI/Bvl2jcucLZRAaFV2BmwwNnjYCynfDBXQZE0gQAAEqfSURBVP4Bp/8FEtTNREREREREWhbNOlTBhjhVV+dZtFqt1hjP5PC35UBVyLUXl+wMOk9NNJNpS/CdN5nZUBlasLG6hewE8GRAACH1HVraRlF8sAXn7GN7Mq5PJsy7BewH29UccykMPrXFZ4uIiIiIiEB061AFG+KUgg0dp6iqmY4OByUnmslN8xeNbCoIEC7YUFLd8v0bDhacNBuDO1dU1jWfFXGgsp4emUncM/MoWPUibPnU80JqV5jxfy0+V0RERERExEvBhiNAaaknrT89PT3GMzn8VQUs6Mf1ySInJbQTRYrVjNVi8nWLCAw2BHaQ2FVSE/Jeb/ZBc2obPPczGoKDDc4WulFU1zt49qdjSavbAx/+2v/CGY+CVf92REREREQkctGsQxVsiFMVFRVAZP1NpW2q6j3BhtzURF65bgLf3jOdc0d3DxqTdLBwY6rVHPQegK7p/qhfdUNoxkN5rT3kWmNNZTAEPiecFfeezKDcFHj7Rqj3FHNh5I9h0CktPlNERERERCRQNOtQBRvilLcwR3KyivsdSm6325d5kBHQgcK7rcEr0ez5VvLWbagMCAJkJyeSYG76W62spuVgQzTbMnzcboxr34QnT4TtX3uuZfSC0x5q8XkiIiIiIiKNRbMOVbAhTpWVlQHaRtHenC43K3aWUlnnCQDU2p2+1pTZyf7tE43bVXoLN3q3TAQ2iXC4XGSGaZXpVRxBTYimMhsCu02E+Pqv8NrlsG+V/9qsR8Ca1uLzREREREREGotmHRrav0/iQmVlJQCpqakxnsnh5fHPN/PXTzaSnZzA81eOIyvZ32HCu0UC/K0ovcwmTy2FcC0x6+wu0pMsFFSEDyrsC9MOM+QeDk9mQ+MKDfWNgh4+W7+AzwIKQGb0gsl3woBpLT5LREREREQknGjWocpsiFPl5Z799wo2tK8P1+wHPEUbr3zuW/aW+QMBXVL9mQ3ezAcvb5eIwGKQvrH19qC2mI25m6/xeHCQd2zwYIfLjaPRlg4q9sJrV/rfNOk2uPl76kb8JIIHiYiIiIiIhBfNOlTBhjjlrQKalZUV45kcPhxOF2v2VvjO91fUsWRbse88L81f6LGqPriGgjcE4C0UGajO7grKkGgN98En2J2hkYmgay6nJ9BQU+Q57z8Npt7LO9/t5Zevfd+mOYiIiIiIyJEtmnWogg1xqqbG00LRZrPFeCaHjy0HqkOu7Smt9R3nB3SVcLqCswm8LSgTzaHBBruz7cGGBofn/q4waRD1joDAx1d/hp2LPMdpPeC8p/lsYxE3z13VYucKERERERGR5kSzDlWwIU7Z7Z40foul6cKDEp3vdpWFXCsNKMCYHRAwcDTKMLAf3MqQaAn9lqqzO0lLatvXyVsvItyWC4c38LFjEXz5J8+xwQTnP8Pueiu3zl2F2x3aQUNERERERCQa0axDFWyIUwo2tN687/Zy/IOfccVzy3jv+32+zhJr9paHjK23+xfogVskahu1oqxt8Jwnhmlx6XS5gwIVXkPyI6u3ceNJA5jQL9t3r0Amo4GURAtU7INXLgP3wfmeeBf0Oo7bXvmO8lrPv5XGHTRERERERESiEc06VN0o4pTD4UmJV7Ahek99vZU9ZbXsKavls/WFTBqQw3+vGs8Pe0KDDXUBWxQSAgIJjbtAeM+9LTADudzQNT0p6FqSxUSvLBvr91c2Oc/rpvTn/DE9GJCb4rtW3RC8FeKu04ZgNbrg9augutBzse9kOOEXAKwLqEFhV2aDiIiIiIi0QTTrUAUb4pQyG1qvoja4k8SCzUWs3VvBun2hC//qgEKQgYGExh0gTAe7UXi7UgQyANkpwZkNuWmJdA2oAeGVlZxASXUDJw/N467ThoS8XheQUTH72J5cfUI/eP9O2LHAczG1K5z/HBg9WRgmk38+qtkgIiIiIiJtocyGw5zT6cR1cJ9+QkLbCg8eiRyu0MIHj3+xOWRrBAS3mvQWZ3S73SELd+8tDYbQYIPRaCCnUbChS0oi+Y2yHRJMRr6840RW7SpjbJ/w1V1rDm7XGN83i/87ezgsexqW/vvggyxwwRxIzvaNNwXMx/teERERERGRaEW7DlXNhjjkTV0BMJlCux+Ip4bCK8t28e32kqCAAYQvsvju9/tavKc3e6He4aJxvMKbcWAKk9lgMhhItQZH/nLTEklLCo712RJNpFotnDCwC9YwLTQBymrsDMhN4d+XjCFhxxfwwS/9L876G/QaH3bOEFrvQUREREREJFLRrkOV2RCHnE7/X6gVbAjvwQ/WMeebHQAM757GL2YM5qTBuYA/QyEvLZH0JAsbC6oiuqe3ZkO42gfe4othYg2YjAZfNwmvvDRrSAAikvaYfzh3BGeO7Ab7f/AUhHQd/IafcCMcc0nI+MCtH3angg0iIiIiItI60a5DldkQ5xRsCG9Dgb/+wuo9FVw151uKquoB/1/4TQYDxw/IafY+DQELdO/CPbCOg5c3gyBc8oDZZAjqZAGQZUsICUCE61jh47RD5X7O7FELq16Gp6dD/cHij4Nnwsn3h31bYCvOqnp72DEiIiIiIiLRUGbDYarxtgAJVduoPoHT5ea+t1ezZm8FhZWeoIPJZOD6Kf15a+UeSmvCL8TrA+o4eAMG4TIbvIUhw31pLCZjSC2HnNREUhODv/1yUhLDf5i178C7t0BNcehrPcbBeU/5CkI2lhCQ2VBnd+F2u8PWlRAREREREWlOtOtQBRvksBSuGOL7P+wPuZabZmXRXdOotTupqLUzf10B//feOt/r5QGdK5ITPN8uzX2PuQl9MSFMO8xMWwIZtkZ1HFLDBBtWvQxv3wDuMG0r07rDT+ayt8ZItyaSIlIaBTTqHa4m60GIiIiIiIi0FwUb4pyyHMIL11miMW+nhqQEE0kJJrKSE7jqhH5sK6rmxSU7AX99B/C3kaxuCG0h2dxXIXArg1dWckJIN4re2Tb/iaMBPv0dfPMP/7XsAdB9DFgzoOtIGHQqW6sT+HD1Hm44aUDYZyc3CjZU1NoVbBARERERkTaJZB2qYEMcCtwfE1ikQ/zq7GEyARoxh8k4AHAE1GkI/BbybpWIdhuFLSF0cZ9kMZEccP3koXlcMakfFKyFT+6FbV+Bs8H/hnHXwqkPgtFIvd3J1qJq5i8pYM6i7Zw3pkeTn7Hxswsr68lNszY5XkREREREJJxo16EKNsQhs9n/ZQtsPyJ+9Y7IMxsas5j918sO1nIwGQ0kHuxG4QhTBdJ7JVwgwrv9IuhaogmDwcBpw/P59elH0TPLBvu+hzmzoK48ePC038CkWymtsXPcHz+l3uFiYG4Kmwo9XTSaCyo23kbhLZIpIiIiIiISjWjXoQo2xCGTybNQdbvdNDQ0tPyGI1D9wVaUaVYzFXXhvxHMpvDBBrMxNOPBZjH5Ciu6wgQbvEGGcBkVjVtcJpiMvjaa/7p4DKx/H+Y9Adu+9A9KyYd+U2DEbBg4HYCtRVW+zxWYsdBcClNKo44XdRFsLxEREREREWks2nWogg1xyGAwkJSURE1NDbW1tbGeTqfjdrtpOLgoz0+3UlFXFXacsYnMBu+WiECBi3a7M3Rx7219WWsPDWwkJ/oDAz0yk3j6smPpkXmwPsO6d2HuRY0elgc3LgVretDlyoCgSeB8mstsaBzoCNe2U0REREREpCXRrkMVbIhTycnJ1NTUUF1dHeupdDoNAVsZMpKaaNNA01stwq3d0wIW7eG2Svie7Qh9ty3BRJ3dSWqimWd/OpZB5kJ44nQo2gSOOv/A9J7Qfyocd0NIoAGC23kmWfzfus11skxPCg421CizQUREREREWimadaiCDXHKZvP8ZbympibGM+kYGwsquXLOMtKsFq6b0p+ZI7piDJOBAOAM2OZgamIMNN2xItxb0pL83yrerIkgbu//Cw02pFktlFQ38PCFIxmU5oSnZ0Px5tB73PJDs5GDynp/ZkNgh4umCl1CaLDB0UygREREREREpDnRrEMVbIhTCQmev9gfKTUb3lixh10ltUAtP395Jc9/s52Xrz4u7ELbHpBdYDE3vRA3EH5hH25bQnozGRLgD2o0DkRMGpDDBcf2pFtGEt1SLfDyj/yBBms6OB2Q0gVO+EXzKQp4Olh4ldX4v+6WZgIqocEGtUoVEREREZHWiWYdqmBDnLJYPIvIIyXYUNyoi8Ky7aWs31/J8O6h2w3sLv+Cv7mFeFOZDeHW/FnJ/kV7uOW6N+gRWIzywrE9+dN5R8POxbB8A7x/u7+dZVIWXPMFZPYGPBkHa3aVMbJnRpPz7Zrub1npCbx4JDQTUMm0BQcbmvrMIiIiIiIiLYlmHapgQ5w60jIbymvtEV2D4MyE5hbXYbdDEH5bQlZyou/YGa715cGHVtV55jT9qFz+cM4IWPIkfHBH6ENmz4HM3tzx6nfsLq3l+91l/O6s4c0GGzICAgeFlf5aD9aAjIfQ9wRnZETSElRERERERCQcZTYcARITPYvfIyXYUBYmsFBdH76lpSsg2rB+f2WT96xpCP9+W5jFe26qP9gQLvPBcTAAUWt3MTA3hb//+BhM696CD+4MHXzsldB3MuW1Dby6fLfvcktZB9kBAY/AFpuJzQQbGm+jGNYtNBNEREREREQkEtGsQxVsiFOpqakAVFRUxHgmHSOw7aNXdRPBgsDMhgybpzhjOHanG5fLHVJoMjkx9NsiP2ALQ+OWmRk2CzeeNACApy4d42lruX81vHkdvk0XfafAiAs8bS37T2XD/gpMxuAMitomPk/gc5IsppCgRLjgiFd2cgKD81LZUFDJzBFdOXVYfrPPEBERERERaUo061AFG+JUVlYWACUlJTGeSceoqg/NbKhtCL8NIjAWMDA3hVOH5fP4F1vCjq2xO0lpFFzITA7OBhjRPZ1JA3N85+aA4ESGzcIb10+kn7Uals+hR30F1FfBlw/6bzDyJ3D242Aw8Pn6Qr56fwM5yQkc0zsr6DlNbevwfy4DXdOtbC0KbjOTYm3629hoNPDKdRPYWFDJsb0zMbRQhFJERERERKQp0axDFWyIU0dcsCFMZkPgdok6u5NnFmzj03UFTB+a57tuwMAdpwzGbDLy2KebQu4RrhXk1CF5jO+bRb3DxeXH92HW0d2CWmhaTEYMBkgwGXn56uPoZ6uDJ6dD+c7QiXcZArP+xoItxVz89BLf5ZunDaS4OrjoZUvBBoC8tNBggy2h6cwG8GylGNsnq9kxIiIiIiIiLVGw4QiQkZEBHDnbKKrrm65nsGF/JZf/Zyl7yz1FE1fuKvO9ZjIZMBgMnDosP2ywwR6mFWR6koW5105o8nkjeqSz/oFTSTSbwOWEOT8KH2jAANN/BxYrz3z9fdArbrebsprgbI36MIGPxvLSEkOuhdv2ISIiIiIi0t6iWYdqlRKnkpOTAaiurm5hZPxzOF00hFmIezMB/rt4hy/QAME1G0wHtw1kJQd3ZfAyN9Masynptbvhq6ehthR2L4OijZ4XUvLglD9AYipYbJDVF2dqd0xAcaO6ES53aDeNSDIbemTaQq6lWS1hRoqIiIiIiLSvaNahCjbEqbS0NADKyspiO5EOUNfEItwbU2j8l/0+2Ta2F9cA/mBCU8EGkynKYEPhOnhuJtQUB183GOHsf8GAaXy7vYRdpbUU7qxj6lFVDMxNpapR5wyX201Fo2CDPYLMhh6ZSUHnRkP4bAcREREREZH2Fs06VMGGOJWT4ylYWFxc3MLI+GdvItjgrbfQKyv4r/29spN9wQZvQCLBbCQ9yRKSTWBp1BGiWXuWw0s/Cg00dD8Wpv8Gd58T+MlTi/lmi+f1sX0yuXZKfwDKG22ZcLrdIXNxhNnS0dig/NSg8/tmDSVVmQ0iIiIiItIBolmHKtgQp/LyPEUQ9+7dG+OZHHp2lz/YYDR4tiAAOA4e9MkODjb0zbbx1cFjd8Ceiq7p1pAFfsSxhlUvw7ybwXmwqGOXo+Csf3i2TqT3YFtxDSlVDb5AA8B1BwMNEKZNpzu0nafT1XKwYXTPDK6c1JftRdXcNG0gI3tmRPgBRERERERE2iaadaiCDXGqW7duAOzbty/GMzn0AmINntaN7uBFeb8uKUHnvbKTfcfGgFaP+elW1u+vDBobUWbD0qfg/dsDHjABfvwyJGXy9Ndb+XLjUipr7bz5s+MZ1yeLVbvLuGPGYKYd5e+KMaFfNp9vOOA7NxkNlDSq4+B0txxsMBgM3DtraMtzFhERERERaWfRrEMVbIhT3pYjFRUVuFwujNFsB4gzgYUT06xmSg9uSai3ezpUNK5Z0C/HH2wIbI/ZLSO43kGCyYixuQKRLid88Uf46s/+a2Muh9Me4psdlVz9/Ee+WgzH9s7EYDAw99rjqG5wktKojsS/Lh7Dswu38Y/PNuNwupk8qEtQ8AFCYigiIiIiIiKdSjTrUAUb4pS3MIfb7aa6uprU1NQW3hG/6hz+tpcZtgRfsKH2YLDBYAgOGPQNCDZUN/jf27NRJ4fZY3uEf2Dpdlj2NGz6BA6s91+fdBtMuw8MBq6asyzo3vnpVt9cGgcaAKwWEzecOIArju9LVb2DnJTEkAKRIiIiIiIinVk061AFG+KU1WrFbDbjcDioqKg4rIMN9faAzIYkfzFEb8ZD41oHe8tqfceBHR7OHNWNF5fswGIycucpgzl1eH7ow3YugZdmQ12Z/5rBCDN+DxNu8F3qlZ3Mun2e3rKnj8jnvjMi29pgtZiwWkwA1DSq4+BWaoOIiIiIiHRi0axDFWyIUwaDgaysLAoLCyksLKR79+6xntIhUx+Q2WA7uFAHf4HI3aU1QeM3FATXZfDqnpHE13eeFJIJAYDTDosfh89+7y8CCZA7DGb+FXpPCBr+r4uO4YPV+5k8KIdh3dKj/UgApFotviwN8HfOEBERERER6YyiWYcq2BDHunbt6vsiH84aArITEi3+PUHeegzr9gUHFzYWVPmOjY0CC2EDDSVb4ZVLYf8P/mt9J8NZ/4SMXmHn1CcnmetP7B/2tUj9dfZIbn55JXvL6wDITU1s4R0iIiIiIiKxFek6VMGGOJabmwvA/v37YzyTQ8scUHQkMFTgcHqCDRsbZTKs318RdnxYa9+Bt38G9d73GOC46+Hk+8FkafatbTW2TxZf3nkSry/fzfbiGq4+oe8hfZ6IiIiIiEhbRboOPXxbGHQCK1eu5KyzziI/P5/evXtz6623UlBQ0G739/Y4PXDgQAsj45sp4F9pYJaDG1i2vYQFm4uCxq/eU+47djVVB8HpgA9/Ba9c4g80ZA+Eqz+DU/94yAMNXhaTkR+N68Vdpw0hO0WZDSIiIiIi0rlFug5VsOEQeeKJJzjmmGP4+OOPOfnkkxk2bBiPPPIIgwYN4vvvv2+XZ6SkpABQVVXVwsj4Frj1IXBbxGvLd3PBE9+wdFtJ0Hi70x9gcIWLNTga4I2rPTUavIad6wk0dD+m3eYtIiIiIiJyuIl0HaptFIfA7t27ueWWW8jNzWXBggUMHDgQgFdffZXZs2dz5ZVXsnTp0vD1A6LgrfxZUVHRwsj4FtilIdFsanJc94wk9gR0ooBGmQ1VB2DZU7D6DSje5LlmtHgyGcZeBW38eoiIiIiIiBzuIl2HKrPhEJg7dy719fX87Gc/8wUaAC644AImTZrEt99+y5o1a9r8nPR0TxeEwz3YELBzgkRz+H+yQ7um8dbPjic10R8/MxrgpMGe/UQc2AhPnQRf/skfaDBb4UcvwbirFWgQERERERGJQKTrUGU2HAILFy4E4Mwzzwx57YwzzmDBggUsXLiQ4cOHh33/3XffDUBSUhJpaWlYrVYsFgvJycmkpaXRtWtXRo4cSXJyMgDV1dWH6JN0DmaTPxBQa3cGvZZgMvLhLSfQPTOJRLOJk4fm8cbKPZiNBv518TGcPKQLrPwvfHwP1Jb635jRG87/D/QY01EfQ0REREREJO5Fug5VsOEQ+OabbwAYMmRIyGtHHXWUb8y1114b9v0PPvggLpcr7GsAffr0Ydu2bb70lcrKyibHHg4sAd0oGreyvHBsT/p1SfGdnzO6Oweq6vnVaUMYmmuF/54LW7/wvyF/BJzxGHQdCcamt2SIiIiIiIhIqEjXoQo2tDOXy0VBQQE2mw2r1RryenZ2NtB0mxC3291soAH86SpxE2zY8CHkD4e07q3arpCc6A8KJJqNZNgslNXYyU1N5JbpA4PGnjCoCycM6gINNfD6lcGBhqPOgLMeB2taaz+JiIiIiIjIEU3Bhhix2+243W5fhc7GvF+Yurq6sK87nc6w1wPV1nqKICYlJQWdd0qV++HlCz3HthwYehbM+D9IsOFyu0MyFcKxBPS+NBjgyUuOZeHmIi4a38vfLtLlglUvwvr3PDUZakqg9mCXCnMS/OhFGDCtvT+diIiIiIjIESXSdaiCDe0sISEBo9FIeXk5brc7pONEWVkZADabrcl7XHzxxTgcDmpqaqisrKSurg6Hw0F5eTnV1dUUFBTgcrnio2bD3lX+45oi+PYZ2Po5jLsGY2IaDD8Xt9kaUWcOgwFG9cxgXN8sxvXN8r9Qvhvm3QKbPwl9kyUZLnhOgQYREREREZF2oJoNMWIw/H97dx7fVJX3D/yTtWnSpOm+0AJFNkHZVPwBMoqCAi5MUdwRH/dRXuiIw4zLoDLiuI064DOjjDoO4goKjuPKgztWEBAe2QbBqqXQJWmTNEmzn98ffc6dpGlLiumS8nm/XnlB7z03uff023PP+d5zb1QYMGAAKisr4fV6lV+EZLfbAQD9+/dvc3utVosXX3yxw88IhUJQqVRKwsLr9SZhz7tI1kBg8kKgeltLkgEAGr4H3v9dy/+3/QOqGY8AGfmAuQjBiIiZyQD8586Lx+aMxoVjioC6vYDPCfz4BbB/A/BTBSCibj3RGVteBSOAGY8C+fHPziAiIiIiIqLOS3QcymRDF5g4cSIqKyuxbds2TJ48OWbd1q1bAQCTJk066vfXalt+bfJWDbfbfdTv1eXyhwNnLW75/6HtwMpZgM/xn/VVm4AVp7f8P+946M55ABh0JhD1UEghgCtO7Y8Lx/YDXr0C+Pc7bX9WRgFw3hPA0Bkx2xMREREREVFyJDoO5YisC8gEw9q1a2OWCyGwbt06AMBpp532sz8nJZINUdw5JwA3fAxMvR/4fzcD+lbPtajfA6y6EPjT0JbbIhp/BACUZKVjafmJwJbn20405AwGTvs1cPNXwPBzmWggIiIiIiLqIomOQ1VCCNEdO3QscTqdGDRoEJqbm/HGG29gxowZCIVC+MMf/oAlS5bg3HPPxb/+9a+f/TnV1dUoKSmBRqNBKBRKwp53rY/31sHlC2LGCUXQa9WAsxrY9FfAdQiw7QNqvo3dQK0DRl0MnHBhywMf/zkfCP3fgzWLxwGjLwOGTAWyB3X/wRARERERER2DEh2HMtnQRT788EPMmTMHLpcLo0ePhsPhwI8//ojhw4fjo48+QlFR0c/+jPr6euTn5wNo+RYLdS+/ou8PhXHOE5/hB7sX+eY0LJl1AqYMz0OaVtPybRK73gR2vtnydZXBDh42cvI1LbdLEBERERERUbdKdBzKZEMXamhowBNPPIFNmzYhLS0Ns2fPxty5c5VnLvxcDocDWVlZAFq+SjMtLS0p79uVGj0BVNo9WPnlD1i3/RDUKsCg0+DCcSWYN3EgBudnAM2NwJdPAZv/BvidsW8weBpw6cuAVt8zB0BERERERHQMS3QcymRDCmtqaoLFYgHQ8rUjHX2dZm/zwsZK3Pf27rjl/bONuHriQFzx//ojLeIDdq0FancDOgOQM6TllgomGoiIiIiIiHpEouNQJhtSmNvthtlsBpB6yYZ9tU04+4nP2l2fm6HHxSeXYtH04fD4Q/AGwmj0BjA4LwNqtaob95SIiIiIiIikRMeh/OrLFBaJRHp6F47a0AIz/nzpGHxf70H52H644tlNqHY0K+tt7gB2HXIhGI5g7JL1CIQjGFqQgQ9/fXoP7jUREREREdGxLdFxKJMNKSz6l6zRaHpwT47OrDH9lP8/f/UpeOfbw7AYtHjgnT0AgIoDdix+aycC4ZbjHFZo6ZH9JCIiIiIiohaJjkOZbEhhwWBQ+b9Op+vBPfn5hhWaMaywZSpOXZMfKz77HoFwBK9srlLKzBpd3FO7R0REREREREh8HNq7vyuROuT3+wEAWq2213/tZWf816SByM2IfaLpSQOycNbx+T20R0RERERERAQkPg7lzIYUJn/JqfCVl51RlJmOL347BQfq3ahqaIbbH8LU4/OhUvHBkERERERERD0p0XEokw0pzOPxAABMJlMP70nyGXQajCzOxMjizJ7eFSIiIiIiIvo/iY5D+87c+2NQc3PLtzekp6f38J4QERERERHRsSDRcSiTDSmsr95GQURERERERL1TouNQJhtSGJMNRERERERE1J2YbDgG8DYKIiIiIiIi6k68jeIY0JcfEElERERERES9Dx8QeQxoaGgAAGRlZfXwnhAREREREdGxINFxKJMNKcxutwMAcnJyenhPiIiIiIiI6FiQ6DiUyYYU5nK5AACZmZk9vCdERERERER0LEh0HMpkQwpzOBwAAIvF0rM7QkRERERERMeERMehTDakMPlL5jMbiIiIiIiIqDskOg5lsiGFud1uAIDZbO7hPSEiIiIiIqJjQaLjUCYbUlii329KRERERERElAyJjkOZbEhhTqcTAJ/ZQERERERERN0j0XEokw0prKmpCQCTDURERERERNQ9Eh2HartjZ6hrrFmzBh6PB6NGjerpXel2QgiEw2GEQiGEw2FluUqlAgBoNBrodDqo1cyndYdIJIJQKIRIJAIhBCKRiLJOrVZDr9dDo9H04B6mJiEEAoEAQqGQskylUkGr1UKn0ynxTomLRCIIBAJxMarVaqHRaFinSSKEQCgUQjAYhBACQEu7zHo+OpFIBOFwGOFwOC52Zb2yTpNHxq88rwEtda1Wq9m36AKRSATBYFDpQ8g2A2C70ZVkfy26/xZd97J90Wg0UKvVrP8kkHUuX+FwWKlzWcep0qY3NDQAAKxWa4flVCI6qihlCCHgcrlgMBig1+t7fUACLfvs8/ngcrnQ0NCAQ4cOoba2FjabDS6XCx6PBw6HAw0NDWhoaEBTUxP8fj8CgQCCwSACgQC8Xi88Hg98Pl9Mh6s9smMgB2c6nQ5GoxFZWVnIzMyE2WyG1WqFyWSCxWJBVlYWDAYDDAYDTCZTTJnc3FyYTCaYTCakpaWlRJ1LwWAQTU1NSv01NTWhpqYGNpsNHo9HWeZ2u9Hc3Ayfz4fm5ma43W5lO/kKBALw+/3w+/0IBoMxg4mOaLXamLpNS0uDXq9X6lm+zGYzMjMzYbFYkJ+fj4KCAuTl5SE/Px85OTnQ6/XdUGNHJxwOo66uDg0NDbDb7Th06BAaGxuVOna73fB6vWhqalLqW9ZxU1MTfD4fgsEgfD4f/H7/EWNcp9MhPT0dZrMZFosFGRkZsFgssFqtsFgsyMzMVP5vtVqRnZ2NzMxMZGRkwGw2Iy8vD1lZWSkRyx6PBzabDXV1daiursbBgwfR2NgIu92Ouro6uFwueL1e+Hw+Jc79fj88Hg+am5sRDAZjkjZtUalU0Ol00Ov10Ov10Gq1SE9PR0ZGBkwmE9LT02EwGJCZmYmsrCxYLBZYLBZkZ2ejsLBQqVtZ1xkZGTAYDClRv9GEEAgGg7DZbGhsbERzczOcTqfSTns8HtTX16Ompgb19fXKy+l0KnHdUV2rVCro9XrodDpkZGQo9ZaZmYns7GwYjUaYTCZkZ2fDarXCarWipKQEeXl5yMzMRE5ODjIzM1NiwNfc3IyGhgY0Njbi0KFDqK6uRl1dHZxOJ7xer9LOer1eOJ1ONDQ0KHXs8XiUc190Ur09Go0GaWlpyqt1+yDrNi0tDRaLBQUFBUpdyjYhNzcXOTk5yMjISLnzXDgcRn19PaqqqmC322POaz6fT4lbu90Ot9sNj8ejtMderxd+v1/5nRzpvCb7EtHtg8FgQEZGBoxGIywWC/Ly8pR2QLbBmZmZKCgoQL9+/VKm7ZUikYgSry6XCw6HA01NTTH12tjYqMS2bIubm5vR1NQEl8sFn8+HQCCAQCCgnOdkkiERarUaBoMB6enpSv/BaDTCaDTGtCEynmWfQvbjovt0hYWF0GpT85qr1+uF3W5HU1MT6uvrlXajsbERDQ0NcDgcSnss223Z35B9aL/fD5/Pl1D/TZL9NtlGyzqXfePs7GwUFRUhLy9PWSZ/F7IdysrKgtlsTqm6D4VCqK2tVepZxrXX61Viv66uDocPH4bT6VT6yfJ30NzcHDOeSZRGo1HOldHnS9n3kGOX6DYmLy9P6YMUFxcjJycHZrM56W2NEAJbt26FEAKjR4/usG/OZEOK8vv9MBgMAFo6brKBlY2rPAHKjprFYkFOTg6ys7OVTrPskKSnpyuDP9lBkRl8OYNAdniCwaDSYMkOvTyRyJNOdIeztrZW+QNsaGg4Ymc/VaSnpyMvLw8ZGRnIyspSBsLyD1+e1GQnTnbc5GAlOvkRnTWWnWd59UrWu8/nU07SHo9HadhkUsbtdsNutysdLNkhkCcc+RCXVKdSqZCbm4uCggIUFBTAZDLBarUiJycHWVlZyM3NVeJdJo6iG2qDwYC0tLSYLL1KpVLiPBAIoLm5WYlpWZcy0SIHAHJgYLfbUVNTg5qaGhw6dAj19fWdOnH3BlqtVqk/o9GIvLw8paMgT2AySZGTkwOr1Qqj0agMyg0Gg1K/8uoTAOUqbCgUUpJTzc3NcDgcMZ1/2XGVA1v5s+wkyQGYy+Xq4Zo6OgaDAQUFBUobLQd80W12dKfNYrHAaDQqA5foGI6OWQAxM4nkLAKZrJJJQ5fLpXTyZcdUDraam5uVzqmMcafTCafT2evbaq1Wi+LiYuTn5yuDDVmvOTk5sFgsSEtLg8lkgtlsVgbZ0YNDeb7T6/Ux5z5Zv7JdkINQj8ejJMtljMpzXmNjo3K+q62tRX19vZIwT1UZGRkoLCxU4lCey+R5T7YZZrNZSb7J/oRsF6IHhlqtNqZ+o6/shUIh5Vwn+xNNTU3KAFbGq9/vV5bbbDY4nU7lIkWqtREajQYmkwk5OTkoKipS2onoAVrrn2V7kZ6eHtOfkP2H1u2DrNvo9iEYDKK5uTlmACrb5sbGRiWRIGO8vr5eSZIlmhRIBWq1GllZWcrALPpcJ8+Dsl8hB3bygolsL6LrvnWfQr6i618OOKP7z7KuZd+5dYJMtjNut1tpa+S98qlMo9EoSaKMjAzl/ChjPLovLROgFotFWS/7IdH9D1n/rft10XEv+yNOp1Op5+bmZrhcLjQ2NqKxsREOhwO1tbU4dOgQampqYLfbe7q6fhaVSoXs7Gzk5+fHJOhk0sJqtSI/P19p1+X5UZaT/RA5azy6LVepVLBYLB0mM5hsSFFOp/OI01Z6KxmYRUVFStYtenaBbHAsFotyhVG+ZDY1uvPSemqdHOS0bmTky+v1KoP0pqYmOJ1OJSPsdDqVgb3X61Uy9/LKVCp3HIH/XI2RV7Xz8/OVjrc8mcoOjOyUy466vIojB5jRJ1v5kr8L2QjJgZBs5GXdyqvOMnkiO4zy9yFPvNGdd7vdnhIDedmBycrKQnFxMXJzc2OuAsj6N5vNMR1I2aHX6XQxiT/ZwMtElBxYyitC0ck+mWCSA0wZ09EnUXmClXWdStLS0pCbm4uSkhL069dPaTvkrAJ5UpT1LQebrRMiMlbVarUy4JGDHZngk//3+XzK1SAZw7IeZR3abDbU1tbC5XLB7XYrHfZUJ2M5PT1d6ZBEzzooLi5WOuXyaoqMZdk+ywF89K1v0fUbnVySnTzZEbfb7UpST85kkcmqVKLRaJQ4LSkpQUFBgVKvsp2VHT+ZtJav6Jk2Mmblv7JOo8938mqlbB/k4F0mnuUVZ4fDgbq6OtjtduXKp8vlQn19fUrHrlqtRmFhoXJukwMTOaMuJydHuVAgO93RySh5npPtsOxUA4hpK2QSWib25dXi6FkqdXV1cDgcSv9CJqrkFdJUpVKplOSoTIZkZWUpg3Or1arEtuw7yPOcHLS07kdEx3f0ICY6YSLjXA4OZf8h+vcg2wh5TpTthWyr5TqHw9HrE6pHotPpYDabkZOTo8y8lRdf5Oy76ARVdH8uLS1NSZzIi17RSRPgP8lW+TuIPjfKNlomQOT/7XY7Dh8+rFz4kq/oCwher7eHa+7oaLVaZSAu2wmj0Yjs7Gzk5eUhNzcX/fr1g9VqVRLY0ReA5awQvV4f045Ht+fyAoKM+egLvdHnSxnX8mcZ4w0NDUobLi/0dse4xe12w2QytV93Xb4H1CUsFotypVBO04weZMgBiDzByQ6bnNIdnd2TGW6/399h4yszWjILGT3wj27QZKYsIyMDeXl5yok/Pz9fGdCmwvTXtshkRX19vVK38oqWrFs5uGtoaFAaALfbrdS1nCqf6NRBefuBbKhkBjg/P19JysgrTbITJa9CRc9sMZvN0Ol03VBLXSMSiaC+vh61tbU4fPgwbDabkjiSr+grXfLvIHpgk8itCbLDGT11XnaY5AAgemBQUFCA4uJi5d+cnJyUmR7o8/lgs9mUKfAej0eJZdmBdjgcyhUv2c7I6d1yMHOkaYGy4y6vPMsYjZ49kZOTE3f1IvpWEJlQSBXhcFhpK2T9yjZYziiIrufoRJscEMqrLolMoQf+c9uY7EQaDAZlyrBsE2SnKCMjA+np6UrnNHpmgBxA9Naprn6/H3V1dTh48GDMtFY5yLPZbMqsAlm3cpp89OAwelrrkepYXrGXs6bkdGwZr7L9LSwsVBK5si6PdNWntwmFQkpbUFdXFzcTSXZqZfLC5XLFzJaRA+/oWTaJ3moX3Z8wm83KxQcZr7IDL9sLeeUzOzsbWVlZyM7O7pUx25rst8lbEA4fPqzcDhY9iJNXtaMHbLIPJ89viZC3iMmXjGfZn0tPT1fqMTpuZV0XFxejuLhYGaymah9OikQiyuxQeV6LftXV1cFmsyn9Clnv8oLJkfrLbVGr1cqFBNmfkH0J2U+LvnIv22xZ59FtjUxYpqJAIKC0FV6vN6ZNkX032feQA2vZn47+G/B6vUo/5Ejks8NkX9pgMCh1LS+uyfbGarUqM1pKSkqUMUxOTk63PHssEAhg165dyoURvV6PwYMHH9XfnBBCmbUhYzr6tmhZn3a7XRnXyLGMTCrJ/oi8na+tuD/S+Y0zGyiGvAod3fFKxsMWHQ4HampqMGzYsJTqdHW16GmkMqMJ/OdBVNFXVejni84YyywyHyqaHDILH/0wNXmy5N/8z9P64WnRoh8mxdg9evLKXXQdy7plu/DzyKnkrc9zsn5lW8F2ovPaerhfdD+CbUOs2tpafPTRR8pAUiayjyb2Wl/5b/1wRTk7g7+DridvVWnr4aKp1n5/9dVXmDBhgvKzVqtFc3Nzr0miyvY8uq6P9OzA3rHn1GvIzGsybNy4EZdddhlqamoQDAbRr18/HDx4MCnv3VdEJxWo68lvcoiu78bGRuzZsweRSAR+vx9CCEydOrUH9zI1ta5XSp7Gxkbs3r1baS/0ej1OOumknt6tPkU+O4eOznfffYc33nhDuWKblZWF2bNnA4i9qk7JJdsDSsw333yDyy+/XPn55/RLZX+Cel5f6n84HI6YnwsKCnrVscn2vDN6z95Tn1NdXY2qqirl547u5yHqKevXr8cll1yi/Dx06FD8+9//7sE9Ioq1YcMGxij1at988w3uvPNO5eehQ4cqyQai3qL180jYL6Xepi/GaOrMK6GU4/F4Yn5Opfut6djBOKXejjFKvR1jlFIB45R6u74Yo0w2UJdp/dCW3jQNiEhinFJvxxil3o4xSqmAcUq9XV+MUSYbqMv4fL6Ynw0GQw/tCVH7GKfU2zFGqbdjjFIqYJxSb9cXY5TJBuoyre87MpvNPbQnRO1jnFJvxxil3o4xSqmAcUq9XV+MUSYbqMu0vu8oIyOjh/aEqH2MU+rtGKPU2zFGKRUwTqm364sxymQDdZnW9x3xa6+oN2KcUm/HGKXejjFKqYBxSr1dX4xRJhuoy6hUqpjvLe8LDzmhvodxSr0dY5R6O8YopQLGKfV2fTFGVUII0dM7QX2bEAKRSARCiD7xR0N9E+OUejvGKPV2jFFKBYxT6u36Uowy2UBEREREREREScXbKIiIiIiIiIgoqZhsICIiIiIiIqKkYrKBiIiIiIiIiJKKyQbqMnV1dbj99ttRUFAAk8mESZMm4YMPPgAfE0Jdob6+Hu+++y6WLFmC8vJyTJs2DX/605863EYIgX/+858YP348jEYjioqKcOedd6KhoaHdbb7//nvMmzcPOTk5sFgsmDlzJr7++utkHw71Qdu3b8fvfvc7jB8/HpmZmUhPT8eYMWNw7733wm63t7tdVVUVbrzxRuTm5sJsNuOss87CF1980W75QCCAp59+GsOGDUN6ejoGDx6M5cuXw+/3d8VhUR/i9/tx1113YcqUKSgqKoJer4fFYsG0adPw9NNPIxQKtbldKBTCCy+8gJEjRyI9PR0DBw7Eo48+Cq/X2+5nffPNN7jggguQmZmJ7OxsXH755di3b19XHRr1YX6/HxdffDGmTZuGu+66q91yu3fvxpw5c2C1WmG1WnHhhRdi586d7ZZ3u9148MEH0b9/fxiNRowePRovv/wywuFwVxwG9SFOpxPTpk1r97V69eo2t2tqasLSpUsTjjkhBN59911MmDABJpMJhYWF+M1vfgObzdaVh9c5gqgL7Nu3T2RnZwsA4txzzxW33HKLyM3NFQDEb3/7257ePeqDzj//fAEg5nXNNdd0uM3NN98sAIjCwkIxf/58MW3aNAFAFBQUiB9++CGu/Keffir0er1QqVTi0ksvFddff70wGo0CgFixYkVXHRr1EaWlpQKAKC0tFbNmzRK//OUvRWFhobLs4MGDcdts2bJFibELL7xQ3HTTTcJsNgsA4tFHH40r7/P5xOTJkwUAccIJJ4gFCxaIMWPGCADilFNOER6PpzsOlVJUQ0ODACCKiorE9OnTxeWXXy6mTp0q0tLSBAAxa9YsEYlEYrYJhUJixowZAoAYOnSoWLBggRg/frwAIEaOHCkcDkfc56xatUoAEGlpaeLaa68VV155pdBoNEKr1YoPPviguw6X+ojf//73ynl/+vTpbZZ56623hFqtFlqtVsybN09cffXVQqfTCZVKJd5444248na7XQwZMkQAEBMnThQLFiwQgwYNEgBEeXm5CIfDXX1YlMLq6+sFAGEwGERpaWnc6+mnn47bxmazicGDBwsAYtKkSWLBggWirKxMABCzZ89uM+Z+/etfCwAiPz9fzJ8/X2mLc3NzxYEDB7rjUI+IyQbqEnLQ9vzzzyvL6urqxIgRIwQAsW3bth7cO+qLnnjiCfHII4+IDRs2iJdeeumIyYZPP/1UABBjx44VDQ0NQgghIpGIWLZsmdKwRwsGg2LIkCFCrVaLjz76SFm+f/9+kZubK4xGozh8+HDXHBz1CTfddJP44osvYgZrHo9HlJeXCwDitttuiykfDofF2LFjBQDx1ltvKcurqqpESUmJ0Gq14vvvv4/Z5oknnhAAxGWXXSb8fr8QoiV2r732WgFALF26tAuPkFKd3+8Xe/bsiUsoHDx4UOn0fvLJJzHrnn/+eQFAnHfeeaK5uVkI0RK7t912mwAgFi1aFFPebrcLi8UiLBaL2L17t7L8yy+/FHq9XpSWlgqfz9dFR0h9zTfffCO0Wq244oor2k02uN1ukZ+fLwwGg9i6dauyfPv27cJkMonc3FzhcrlitrnlllsEAHHnnXcqfw8ej0fp37722mtde2CU0mSyoby8POFt5AWw6Jhzu91i6tSpAoB4/fXXY8p/9dVXyoUFm82mLF+xYoVysbc3YLKBkq6mpka5wtHac889JwCIhQsX9sCe0bHinXfeOWKy4frrr2+zwxCJRES/fv2EWq2O6Xx88cUXAoCYOXNm3HvdeeedAoD461//mryDoGPGDz/8IACIkpKSmOXffvutcoWjtYceekgAEA899FDM8nHjxgkAYv/+/THLq6urBQBx/PHHJ/8A6JjwwAMPtJmwmjJligAQM4gTQgiHwyF0Op0oLi6OSV688MILAoBYsGBB3GfMmTNHABDr16/vmoOgPiUQCIixY8eKk08+WWzatKndZMPatWsFADFv3ry4ddddd50AINasWaMsC4fDwmq1ivT09LjZYJ9//rkAIM4///ykHw/1HZ1NNoTDYZGZmSmMRqPwer0x6z777DMBQFxwwQUxy+fPny8AiJUrV8Ysj0Qiyiwcu93+8w4kCfjMBkq6jRs3AgDOP//8uHVymSxD1FM2btwIrVaL6dOnxyxXqVQ4//zzEYlEsGnTppjyQNtxfcEFF8SUIeqM/Px8AIi7H76zMed2u7Fjxw4cf/zxOO6442LKFxcX45RTTsGePXs6fCYJUXuampoAAP369VOWBYNBbNq0Cf369cPYsWNjymdmZuL000/HoUOH8OOPPyrL2ZZSsjz66KP43//9Xzz77LPQarXtlutszO3evRsOhwNTp06F0WiMKT9hwgTk5ubiyy+/5DPIKGl27doFp9OJqVOnIj09PWbdxIkTkZOTExdzGzduhEqlwsyZM2PKq1QqJa4rKiq6fuePgMkGSrqvvvoKADBs2LC4dXl5ecjOzsbWrVv5sDLqMU6nE7t370ZRUREsFkvcehm70Y10R3HdVnmiRL399tsAgEmTJsUs7yjmhgwZAiA25rZs2YJwONxm+ej3ke9LlIhAIIDVq1dj+fLlGDRoEC666CJl3c6dO+H1ejF06FCoVKq4bdmWUlfZvXs37r//fvzmN7/B6NGjOyzb2ZjrqLxGo8HgwYNht9vx3XffHfX+07GhoqICw4cPR0FBAcaOHYslS5bgp59+iiuXSMzZbDbs378fAOD1erFjxw7k5eUhJycnbpuhQ4cqn9/TmGygpKutrQWANoNfLg8Gg3A6nd25W0SK+vp6AB3HKPCfWI7+f1vbZGZmQq1Wx5QnSoTNZsMdd9wBjUaDu+++O2ZdRzGn1WphtVphs9mUp1Qn0vZGlyNqj8fjUTqxBoMBF198MS677DJUVFTAZDIp5Y4m5jrahjFKiQiHw7jmmmvQv39/LF68+IjlOxtzbEspWQwGAwYMGIBRo0Zh//79uPfee3HCCSfgs88+iynX2Ziz2+2IRCIpEaNMNlDS+Xw+AIjpkESTy2U5ou52NDHa0TZqtRpGo5ExTZ3S3NyM2bNno6qqCg899FDcNPRE41TOEmPbS8mi0Whw1lln4cwzz8SECROg0+nw2muvYdWqVTHTeI+2LVWpVHFThdsrT9Tan//8Z2zatAkrVqxoM45a6yhOO3u+b28bomgZGRnYtWsXKisr8cEHH2D9+vWor6/Hvffei6amJsybNw+RSEQp39mYS6UYZbKBkk4GuMPhaHO9XN7eHwhRVzuaGO1om1AoBLfbzZimhPn9flx44YX4/PPPcccdd2DhwoVxZRKJ0+hBG9teShaDwYBXX30Vq1evxsaNG3HgwAGMHDkSCxcuxJo1a5RyR9uWCiHgcrkSKk8U7bvvvsPdd9+Na6+9FlOmTElom47itLPn+/a2IYpmMBgwYsSIuGX33XcfJk6ciB9++AEbNmxQ1nU25lIpRplsoKQbOHAggJYpPm2x2+2wWCywWq3dt1NEUYqKiqDX6zuMUQAoKytTlnUU1/KBe9HlidoTCAQwZ84cvPfee7jlllvwyCOPtHm/e0cx5/f74fF4MHDgQGXbRNpegHFKnVdaWopHHnkEAPD8888ry48m5jrahjFKR7Js2TL4fD6YzWYsWbJEea1YsQIAsH//fixZsgQrV65UtulszLEtpa4kH964bds2ZVlnYy4vLw9GozElYpTJBko6+ZCzr7/+Om7d3r170dTUhAkTJkCj0XT3rhEBaMkun3TSSaipqUFVVVXc+s2bNwOIfWBfR3HdVnmitgSDQVx66aV4++23cf3112PZsmVtJhqAzsfc6NGjYTQasWXLlpjpmQAghMDmzZuh0+lw8sknJ+tw6BgiHzh2+PBhZdngwYORl5eHHTt2tPnQZxmnEydOVJaxLaWfIxgMAgCefPJJ3HvvvcrrmWeeAQDlvvh//OMfyjadjbmOyns8HuzatQtlZWUoKipK0lHRscTr9QJAzDeodBRzbrcbu3btwqBBg1BYWAgA0Ol0GD9+PBobG5WHRkaT79Mb2lImGyjpTj31VGi1WvzrX/9CIBCIWffmm28CAE477bSe2DUixeTJkwEAa9eujVnu9Xrx/vvvw2QyYcyYMXHl33zzzbivu2JcUyJCoRAuv/xyrF27FldffTWefvppqNXtn4ZlPK1duzYuedBWzOl0OkyYMAG1tbVxT6DesWMHKisrcfLJJyd0jzNRa++//z4AxEwNVqlUmDx5MpqammKmBANAZWUltm/fjhEjRiA7O1tZHt2Wtsa2lI7koYceQnV1ddxLxucZZ5yB6upqvPbaa8o2nY250tJSDBgwABUVFTh06FBM+ffeew8+n48xSkclGAzilVdeAdASq1L//v3Rv39/fPnllzEJXaAl5vx+f1zMtdeP9fv9eOedd5CWltY7Li4Ioi7wq1/9SgAQ8+bNE01NTUIIIT788EORmZkpTCaTOHz4cA/vIfU1drtd7Ny5U+zcuVP85S9/EQBEeXm5sqyysjKmfGVlpdDr9SI3N1d8+umnQgghHA6HuOSSSwQAsWjRorjPmDZtmgAg7rnnHhEIBEQkEhEvvvii0Gg0on///sLn83XHoVKKuuKKKwQAMXHiRLFjxw4lNqNf4XA4ZpuLLrpIABC33XabEl9vvvmmSEtLE3l5ecLlcsWUf/vttwUAMWrUKLFv3z4hREusn3LKKQKAeO2117rnYCklvfTSS+LZZ5+NOUc3NTWJZ599VmRnZwsA4ssvv4zZ5tNPPxUAxNChQ8XOnTuFEEJUV1eLX/ziFwKAWLFiRUz5QCAghgwZIlQqlVixYoWIRCIiFAqJBx98UAAQkyZNEpFIpOsPlvqUrVu3CgBi+vTpcevC4bAYN26cACAef/xxEQ6HRTgcFsuXL1fay9Zt7xNPPCEAiKlTp4qamhohhBDffPONKCsrEyqVSnz99dfdclyUmh577DHxxhtvCIfDIYQQIhKJiO3bt4sLLrhAABDjx4+P2+bxxx8XAMS0adOUmNu2bZsYOHCgUKlUYsuWLTHlq6qqRHp6usjKyhIbNmwQQgjhcrnElVdeKQCIW2+9tWsPMkFMNlCXaGpqElOmTBEARHZ2thg2bJgAICwWi1i3bl1P7x71QU899ZQA0O5rypQpcdu8/PLLwmQyCQBi+PDhIjMzUwAQM2fOFM3NzXHlq6urxciRIwUAUVhYKMrKygQAUVRUJDZv3twdh0kpTKfTdRijAITf74/ZxmaziZNPPlkAEHl5eWLw4MECgMjNzRUff/xxm59zzz33CLVaLfR6vRgxYoQwGAxCpVKJhQsXchBHHVqyZIkSixaLRVitVuVnnU4nHn/88Ta3e/jhh4VWqxVarVaMGDFCGI1GAUDccMMNbcbc9u3bRUlJiQAgBgwYIIqLi5WERevEMFEiOko2CCHEvn37lHN2SUmJKC0tFQDEwIEDxZ49e+LKh0IhcdVVVwkAwmQyieOPP15oNBqh1+vFsmXLuvpwKMXNnj1baTuzsrJi2tKRI0eK77//Pm6bUCgk5s6dKwCIjIyMhGJuzZo1wmw2K/3YrKwsJWHh8Xi6+jATohKi1XxgoiQRQuD999/HSy+9BLfbjTFjxmDBggUx0ymJkmX79u346KOP2l1fWlqKOXPmxC2vr6/Hk08+iZ07dyIzMxNXX301zjzzzHbfJxwO45VXXlFuEzrttNNw0003wWg0JuU4qO968skn426HaO3WW2+Ne55NJBLBm2++iTfeeAM+nw+nnnoqbrnlFpjN5nbf59///jeWLVuGqqoq9OvXD/Pnz8fIkSOTchzUd7ndbqxfvx4VFRU4cOAAfD4fcnNzccYZZ+Ccc85BcXFxu9tWVlbiySefRGVlJQoKCvCrX/0K48aNa7e8z+fD3/72N3zyySfQarWYPn065s6dG3MfM1Giamtr8dJLL2HgwIGYPXt2m2WCwSD+/ve/Y/369RBCYOrUqbjmmmug1+vbfd/NmzfjmWeeQX19PYYMGYLbbrsNpaWlXXUY1Efs378fH3zwAXbs2IHDhw9DrVajrKwMs2bNwuTJkzts5zZt2oRnnnkGNpstoZiz2WxYtmwZduzYAYvFgrlz52LatGntPg+quzHZQERERERERERJxQdEEhEREREREVFSMdlAREREREREREnFZAMRERERERERJRWTDURERERERESUVEw2EBEREREREVFSMdlAREREREREREnFZAMRERERERERJRWTDURERERERESUVNqe3gEiIiLq+2pra1FXV9dhmcLCQuTl5R31Z0ydOhX9+/fH888/f9TvkQxPP/00Vq5ciWeeeQYnnnhij+4LERFRT2GygYiIiLrcX//6V9x///0dlnn44YexaNGio/6MiooKOByOo94+WX766SdUVFTA7Xb39K4QERH1GCYbiIiIqNvMnj0bp512Wpvr2lueqIcffhhZWVk/6z2IiIgoOZhsICIiom5z1lln4eabb+6S954/f36XvC8RERF1Hh8QSURERL3Oxo0bcdVVV+Hjjz9GRUUFysvLMWTIEIwbNw5/+ctf4PP54ra54YYbsHjx4phlfr8fy5Ytw9lnn42ysjIcd9xxmDx5MhYuXBj3DIlgMIjXX38dZ599NgYNGoTRo0fjvvvuw6FDh9rcR5fLhQcffBAnnHAChg0bhiuuuAJ79uzp8Lj279+PRYsW4cQTT8SgQYNw7rnnYt26dYhEIp2sISIiot6NyQYiIiLqdSorK/Hiiy9ixYoVmDx5Murr6zFlyhQ4nU7ccsstOPvssxEIBGK2eeWVV/Duu+/GLLvyyitx66234vDhw5gyZQrOOuss6PV6/Pd//ze+++47pVwgEMDMmTNxySWXYNeuXTj99NNhtVpx//334/jjj8fmzZtj3rehoQGnnnoq7r77bmi1Wpx++unYuXMnxo8fj927d7d5TKtWrcLw4cOxfPlylJSUYMKECdizZw/Ky8vxX//1XxBCJKn2iIiIeh5voyAiIqJus2nTJpjN5jbXnX/++bBarTHLXn31VTz77LO49tprAbTMPrjuuuuwcuVKPPXUU7j99tvb/awDBw5gzZo1mD17NtasWQOVSqWsczgcMYP75cuX43/+539w0UUX4cUXX4TBYAAArF27FrNnz8bcuXOxd+9e5T3uu+8+7N27F7///e9x//33Q6VSIRKJYPHixVi6dGncvuzfvx/XXnstysrK8OGHH6KsrAxAy8yLq666CitXrsQll1yCmTNnJlCLREREvR9nNhAREVG3WblyJa666qo2X9XV1XHlx4wZg2uuuUb5WafT4Y9//CN0Oh1ef/31Dj+rsbERAFBWVhaTaAAAq9Ua8zDJV155BSqVCk899ZSSaACA8vJyzJgxA/v27cO2bdsAAJFIBKtXr0Z+fj7uuusu5b3VajXuvvtu5Ofnx+3LSy+9hEAggOXLlyuJBgBIS0vDU089BZVKhVdffbXD4yEiIkolnNlARERE3ebWW2/FL3/5yzbXDRw4MG7Z2WefHZcoKC4uxqhRo7B582Y4HI642RDSiBEjUFBQgD//+c9wOByYNWsWJk+eHFfeZrNh69atGDduHAoKCuLe57zzzsN7772H9957DyeddBJ27dqFmpoaXHzxxTGJCQBIT0/H6aefjtWrV8csX7duHYCWRMWGDRsAAEIIZXZFdnY2Nm7c2OZxEBERpSImG4iIiKjbDB06FGeccUbC5YuLi9tc3q9fP2zduhU2m63dZIPRaMQ777yDG2+8Ec899xyee+45aDQanHbaafjd736H6dOnAwDq6+sBAP3792/3s6LL1dbWHnHfWjt48CAA4Nxzz21zGwBxSRUiIqJUxmQDERER9Voul6vN5Q6HA0DLTIKOnHTSSdiyZQsOHDiADRs24MMPP8Rbb72FGTNmYPXq1bjooouU97Db7Ql9lvzX6XR2WD5aeno6TCYT9u3b125SQa3m3a1ERNR38KxGREREvda3334btywYDGLv3r0oLi5ud3ZBa8cddxxuuOEGrFmzBp988gkA4IUXXgAAlJaWIj8/H7t374bf74/bdseOHQCA8ePHAwBGjRoFvV7f5r61t88TJ06Ex+NBVVUVioqK2ny1dQsHERFRqmKygYiIiHqttWvX4vvvv49Z9vLLL6Ourg7nnXdeh7ceeDyeNr9OcujQocp6ANBoNJg1axbsdjv+/ve/x5S12Wx47rnnYDAYcM455wAAzGYzzjjjDGzZsgWff/55TPnPPvsMW7dujfvMefPmAQCWLFmCcDjc7v4SERH1FbyNgoiIiLrNqlWr2hyMA8CECRNw3XXXxSwrLS3FmWeeicWLF2PEiBH44IMP8Mgjj8BkMmHRokUdftb777+P++67D5deeilOOeUUWK1WVFVV4U9/+hMAxHzLxW9/+1u8+uqruPXWW3HgwAFccMEFqKysxNKlS+FyubB06VKYTCal/OLFi7FhwwaUl5fjnnvuwYQJE1BRUYEHHngAZWVlqKysjNmXc845B+Xl5Vi7dq1ynCNHjoTX68WuXbuwdu1a/OIXv8Af/vCHTtUnERFRb8VkAxEREXWbiooKVFRUtLkuGAzGJRvuuOMOfPvtt7j++usRiUQAtDyHYfny5TjuuOM6/KySkhIEAgHcc889Mctzc3Pxxz/+EVdeeaWy7LjjjsOnn36KO++8E4899hgee+wxAMCAAQOwbNkyzJ8/P+Y9Jk2ahHXr1uH222/Hr3/9awCAXq/HXXfdBZ/Ph4ceeiimvFqtxuuvv47HHnsMf/vb33DjjTfGrB81ahQmTpzY4fEQERGlEpVoa34hERERUQ9atWoV5s6di2eeeQY33HAD6urqsHfvXlgsFowePbpT39xgs9nw3XffwePxoKCgACNHjuzwYYw//fQTDhw4ALPZjLFjx0Kj0bRbNhwOY8uWLQiFQhg5cmS734wRTQiBnTt3oq6uDiaTCUOGDEFOTk7Cx0NERJQKOLOBiIiIer38/Hzk5+cf1ba5ubnIzc1NuHz//v3b/RrM1jQaDU499dRO7Y9KpcKJJ57YqW2IiIhSDR8QSURERERERERJxWQDERERERERESUVn9lAREREvU4oFILf74der4dOp+vp3SEiIqJOYrKBiIiIiIiIiJKKt1EQERERERERUVIx2UBEREREREREScVkAxERERERERElFZMNRERERERERJRUTDYQERERERERUVIx2UBEREREREREScVkAxERERERERElFZMNRERERERERJRU/x8Nu/gtBaddLwAAAABJRU5ErkJggg==",
            "text/plain": [
              "<Figure size 1200x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 0 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 0 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Training Loop\n",
        "total_numsteps = 0\n",
        "updates = 0\n",
        "reward_history = []\n",
        "Max_episodes = 500\n",
        "criteria = 0\n",
        "max_reward = -1000\n",
        "for i_episode in range(Max_episodes):\n",
        "    episode_steps = 0\n",
        "    done = False\n",
        "    state, _ = env.reset()\n",
        "\n",
        "    while not done:\n",
        "        if config['start_steps'] > total_numsteps:\n",
        "            action = env.action_space.sample()  # Sample random action\n",
        "        else:\n",
        "            action = agent.select_action(state)  # Sample action from policy\n",
        "\n",
        "        if len(memory) > config['batch_size']:\n",
        "              critic_1_loss, critic_2_loss, policy_loss, ent_loss, alpha = agent.update_parameters(memory, config['batch_size'], updates)\n",
        "              updates += 1\n",
        "\n",
        "        next_state, reward, done, truncated, _ = env.step(action) # Step\n",
        "        episode_steps += 1\n",
        "        total_numsteps +=1\n",
        "        done = done or truncated\n",
        "\n",
        "        # Ignore the \"done\" signal if it comes from hitting the time horizon.\n",
        "\n",
        "        mask = 1 if episode_steps == env._max_episode_steps else float(not done)\n",
        "\n",
        "        memory.push(state, action, reward, next_state, mask) # Append transition to memory\n",
        "\n",
        "        state = next_state\n",
        "\n",
        "      # TODO 14: Evaluate the policy at regular intervals and log the average reward.\n",
        "        pass\n",
        "      # TODO 14: Here, we are running evaluation episodes to measure how well the policy is performing over time.\n",
        "\n",
        "      if i_episode % 10 == 0:\n",
        "        print(\"Episode: {}, reward: {}\".format(i_episode, round(avg_reward, 2)))\n",
        "\n",
        "      if avg_reward < max_reward:\n",
        "        criteria +=1\n",
        "        if criteria == 50:\n",
        "          break\n",
        "      else:\n",
        "        criteria = 0\n",
        "\n",
        "      max_reward = max(reward_history)\n",
        "\n",
        "env.close()\n",
        "\n",
        "\n",
        "plot_rewards(reward_history, show_result='SAC algorithm in HalfCheetah Env')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "64hZeCpwigKx"
      },
      "outputs": [],
      "source": [
        "env = gym.make(\"HalfCheetah-v4\", render_mode=\"rgb_array\")\n",
        "state, _ = env.reset()\n",
        "frames = []\n",
        "\n",
        "total_reward = 0\n",
        "# run the policy in the environment in a loop\n",
        "while not done:\n",
        "    frames.append(env.render())\n",
        "    action  = agent.select_action(stateوevaluate=True)\n",
        "    next_state, reward, done, truncated, _  = env.step(action)\n",
        "    total_reward += reward\n",
        "\n",
        "    done = done or truncated\n",
        "\n",
        "env.close()\n",
        "print(f'Total Reward: {total_reward}')\n",
        "\n",
        "imageio.mimsave('./eval_SAC.mp4', frames, fps=25)\n",
        "show_video('./eval_SAC.mp4')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# **Initialize DDPG** "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NFjPRvvttgDf",
        "outputId": "b02b212e-38de-4292-f258-0ca4c75f9905"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.11/dist-packages/gymnasium/envs/registration.py:519: DeprecationWarning: \u001b[33mWARN: The environment HalfCheetah-v4 is out of date. You should consider upgrading to version `v5`.\u001b[0m\n",
            "  logger.deprecation(\n"
          ]
        }
      ],
      "source": [
        "# Configuration dictionary\n",
        "config = {\n",
        "}\n",
        "\n",
        "# Setup environment\n",
        "env = gym.make(config[\"env_name\"])\n",
        "env.action_space.seed(config[\"seed\"])\n",
        "\n",
        "# Set random seeds\n",
        "torch.manual_seed(config[\"seed\"])\n",
        "np.random.seed(config[\"seed\"])\n",
        "\n",
        "# Initialize agent\n",
        "agent = SAC(env.observation_space.shape[0], env.action_space, config)\n",
        "\n",
        "# Initialize replay memory\n",
        "memory = ReplayMemory(config[\"replay_size\"], config[\"seed\"])\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# **Train the DDPG here**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "GGE0pNJvtf7M",
        "outputId": "f2b4e927-e1d4-4ddf-8b0b-b7d5e67eba74"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Episode: 0, reward: -578.86\n",
            "Episode: 10, reward: -502.23\n",
            "Episode: 20, reward: 864.31\n",
            "Episode: 30, reward: 1408.89\n",
            "Episode: 40, reward: 333.49\n",
            "Episode: 50, reward: 763.17\n",
            "Episode: 60, reward: 1058.99\n",
            "Episode: 70, reward: 3800.57\n",
            "Episode: 80, reward: 4542.31\n",
            "Episode: 90, reward: 4589.95\n",
            "Episode: 100, reward: 4449.53\n",
            "Episode: 110, reward: 5005.96\n",
            "Episode: 120, reward: 1959.98\n",
            "Episode: 130, reward: 5219.41\n",
            "Episode: 140, reward: 5005.78\n",
            "Episode: 150, reward: 5414.65\n",
            "Episode: 160, reward: 5673.5\n",
            "Episode: 170, reward: 5667.75\n",
            "Episode: 180, reward: 5662.22\n",
            "Episode: 190, reward: 5980.01\n",
            "Episode: 200, reward: 6054.69\n",
            "Episode: 210, reward: 5841.81\n",
            "Episode: 220, reward: 6345.9\n",
            "Episode: 230, reward: 6881.28\n",
            "Episode: 240, reward: 6644.02\n",
            "Episode: 250, reward: 7073.82\n",
            "Episode: 260, reward: 7300.15\n",
            "Episode: 270, reward: 6945.66\n",
            "Episode: 280, reward: 7407.8\n",
            "Episode: 290, reward: 7444.08\n",
            "Episode: 300, reward: 7605.7\n",
            "Episode: 310, reward: 7424.99\n",
            "Episode: 320, reward: 8052.84\n",
            "Episode: 330, reward: 7146.19\n",
            "Episode: 340, reward: 7141.24\n",
            "Episode: 350, reward: 7825.03\n",
            "Episode: 360, reward: 8028.75\n",
            "Episode: 370, reward: 8227.59\n",
            "Episode: 380, reward: 7819.2\n",
            "Episode: 390, reward: 8068.33\n",
            "Episode: 400, reward: 8077.61\n",
            "Episode: 410, reward: 8439.4\n",
            "Episode: 420, reward: 8477.73\n",
            "Episode: 430, reward: 8352.88\n",
            "Episode: 440, reward: 8586.31\n",
            "Episode: 450, reward: 8464.01\n",
            "Episode: 460, reward: 8168.11\n",
            "Episode: 470, reward: 8466.56\n",
            "Episode: 480, reward: 8778.99\n",
            "Episode: 490, reward: 8907.54\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1200x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 0 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 0 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Training Loop\n",
        "total_numsteps = 0\n",
        "updates = 0\n",
        "reward_history = []\n",
        "Max_episodes = 500\n",
        "criteria = 0\n",
        "max_reward = -1000\n",
        "for i_episode in range(Max_episodes):\n",
        "    episode_steps = 0\n",
        "    done = False\n",
        "    state, _ = env.reset()\n",
        "\n",
        "    while not done:\n",
        "        if config['start_steps'] > total_numsteps:\n",
        "            action = env.action_space.sample()  # Sample random action\n",
        "        else:\n",
        "            action = agent.select_action(state)  # Sample action from policy\n",
        "\n",
        "        if len(memory) > config['batch_size']:\n",
        "              critic_1_loss, critic_2_loss, policy_loss, ent_loss, alpha = agent.update_parameters(memory, config['batch_size'], updates)\n",
        "              updates += 1\n",
        "\n",
        "        next_state, reward, done, truncated, _ = env.step(action) # Step\n",
        "        episode_steps += 1\n",
        "        total_numsteps +=1\n",
        "        done = done or truncated\n",
        "\n",
        "        # Ignore the \"done\" signal if it comes from hitting the time horizon.\n",
        "\n",
        "        mask = 1 if episode_steps == env._max_episode_steps else float(not done)\n",
        "\n",
        "        memory.push(state, action, reward, next_state, mask) # Append transition to memory\n",
        "\n",
        "        state = next_state\n",
        "\n",
        "    # TODO 15: Evaluate the policy at regular intervals and log the average reward.\n",
        "      pass\n",
        "    # TODO 15: Here, we are running evaluation episodes to measure how well the policy is performing over time.\n",
        "      if i_episode % 10 == 0:\n",
        "        print(\"Episode: {}, reward: {}\".format(i_episode, round(avg_reward, 2)))\n",
        "\n",
        "      if avg_reward < max_reward:\n",
        "        criteria +=1\n",
        "        if criteria == 50:\n",
        "          break\n",
        "      else:\n",
        "        criteria = 0\n",
        "\n",
        "      max_reward = max(reward_history)\n",
        "\n",
        "env.close()\n",
        "\n",
        "\n",
        "plot_rewards(reward_history, show_result='DDPG algorithm in HalfCheetah Env')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "env = gym.make(\"HalfCheetah-v4\", render_mode=\"rgb_array\")\n",
        "state, _ = env.reset()\n",
        "frames = []\n",
        "\n",
        "total_reward = 0\n",
        "# run the policy in the environment in a loop\n",
        "while not done:\n",
        "    frames.append(env.render())\n",
        "    action  = agent.select_action(stateوevaluate=True)\n",
        "    next_state, reward, done, truncated, _  = env.step(action)\n",
        "    total_reward += reward\n",
        "\n",
        "    done = done or truncated\n",
        "\n",
        "env.close()\n",
        "print(f'Total Reward: {total_reward}')\n",
        "\n",
        "imageio.mimsave('./eval_DDPG.mp4', frames, fps=25)\n",
        "show_video('./eval_DDPG.mp4')"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}