{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NWgZejAtS7Ek"
      },
      "source": [
        "## Configuration for Colab"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vULDQDM3S7El",
        "outputId": "50f61587-c270-434f-e9e2-3b4b8ff66ec8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting gymnasium==1.0.0\n",
            "  Downloading gymnasium-1.0.0-py3-none-any.whl.metadata (9.5 kB)\n",
            "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (1.26.4)\n",
            "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (3.1.0)\n",
            "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (4.12.2)\n",
            "Collecting farama-notifications>=0.0.1 (from gymnasium==1.0.0)\n",
            "  Downloading Farama_Notifications-0.0.4-py3-none-any.whl.metadata (558 bytes)\n",
            "Downloading gymnasium-1.0.0-py3-none-any.whl (958 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m958.1/958.1 kB\u001b[0m \u001b[31m18.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading Farama_Notifications-0.0.4-py3-none-any.whl (2.5 kB)\n",
            "Installing collected packages: farama-notifications, gymnasium\n",
            "Successfully installed farama-notifications-0.0.4 gymnasium-1.0.0\n"
          ]
        }
      ],
      "source": [
        "import sys\n",
        "\n",
        "IN_COLAB = \"google.colab\" in sys.modules\n",
        "\n",
        "if IN_COLAB:\n",
        "    !pip install gymnasium==1.0.0"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C8l1L-DsS7Em"
      },
      "source": [
        "# 05. Soft Actor Critic (SAC)\n",
        "\n",
        "1. [T. Haarnoja et al., \"Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor.\" arXiv preprint arXiv:1801.01290, 2018.](https://arxiv.org/pdf/1801.01290.pdf)\n",
        "2. [T. Haarnoja et al., \"Soft Actor-Critic Algorithms and Applications.\" arXiv preprint arXiv:1812.05905, 2018.](https://arxiv.org/pdf/1812.05905.pdf)\n",
        "\n",
        "The main purpose of SAC is to maximize the actor's entropy while maximizing expected reward. We can expect both sample efficient learning and stability because maximizing entropy provides a substantial improvement in exploration and robustness.\n",
        "\n",
        "As an extension of standard RL's objective function $\\sum_t \\mathbb{E}_{(s_t, a_t) \\sim \\rho_\\pi} [r(s_t, a_t)]$, let's consider a more general maximum entropy objective which favors stochastic policies by augmenting the objective with the expected entropy of the policy over $\\rho_\\pi (s_t)$:\n",
        "\n",
        "$$J(\\pi) = \\sum_{t=0}^T \\mathbb{E}_{(s_t, a_t) \\sim \\rho_\\pi} [r(s_t, a_t) + \\alpha H(\\pi(\\cdot | s_t))].$$\n",
        "\n",
        "The temperature parameter $\\alpha$ determines the relative importance of the entropy term against the reward, and thus controls the stochasticity of the optimal policy. By this objective, the policy can explore more widely and capture multiple modes of near-optimal behavior. In conclusion, it considerably improves learning speed over other methods that optimize the conventional RL objective function.\n",
        "\n",
        "In the paper, the authors show that *Soft Policy Iteration* guarantees convergence based on a tabular setting (4.1), and they extend it to a practical approximation for large continuous domains (4.2). Firstly, the soft value function is trained to minimize the squared residual error:\n",
        "\n",
        "$$J_V (\\psi) = \\mathbb{E}_{s_t \\sim D} \\big[ \\frac{1}{2}(v_\\psi (s_t) - \\mathbb{E}_{a_t \\sim \\pi_\\phi} [Q_\\theta(s_t, a_t) - \\log_{\\pi_\\phi}(a_t | s_t)])^2 \\big],$$\n",
        "\n",
        "where $D$ is the distribution of previously sampled states and actions, or a replay buffer. Second, the soft Q-function parameters can be trained to minimize the soft Bellman residual:\n",
        "\n",
        "$$J_Q (\\theta) = \\mathbb{E}_{(s_t, a_t) \\sim D} \\big[ \\frac{1}{2} \\big( Q_\\theta(s_t, a_t) - \\hat{Q}(s_t, a_t) \\big)^2 \\big],$$\n",
        "\n",
        "with $\\hat{Q}(s_t, a_t) = r(s_t, a_t) + \\gamma \\mathbb{E}_{s_{t+1} \\sim \\rho} [V_{\\tilde{\\psi}} (s_{t+1})].$\n",
        "\n",
        "Finally, the policy paramameters can be learned by directly minimizing the following expected KL-divergence:\n",
        "\n",
        "$$J_\\pi(\\phi) = \\mathbb{E}_{s_t \\sim D} \\big[ D_{KL} \\big( \\pi_{\\phi} (\\cdot | s_t) \\| \\frac{\\exp(Q_{\\theta}(s_t, \\cdot))}{Z_\\theta(s_t)} \\big) \\big].$$\n",
        "\n",
        "We can rewirte the objective as\n",
        "\n",
        "$$J_\\pi(\\phi) = \\mathbb{E}_{s_t \\sim D, \\epsilon_t \\sim N} [ \\log_{\\pi_\\phi}(f_\\phi(\\epsilon_t ; s_t) | s_t) - Q_\\theta (s_t, f_\\phi (\\epsilon_t ; s_t))],$$\n",
        "\n",
        "where $\\pi_\\phi$ is defined implicitly in terms of $f_\\phi$, and the partition function is independent of $\\phi$ and can thus be omitted.\n",
        "\n",
        "One thing to note is that the authors suggest to use two Q-functions to mitigate positive bias in the policy improvement step that is known to degrade performance of value based methods. In particular, we parameterize two Q-functions, with parameters $\\theta_i$, and train them independently to optimize $J_Q(\\theta_i)$. We then use the minimum of the Q-functions for the value gradient and policy gradient. Two Q-functions can significantly speed up training, especially on harder tasks.\n",
        "\n",
        "### Can we do better?\n",
        "\n",
        "In Soft Actor Critic paper, the experiment of reward scale shows that SAC's performance quite varies depending on reward scaling. In the follow-up paper [2], the authors assume that the temperature parameter $\\alpha$ needs to be adjusted depending on the magnitude of the reward, and they define the soft policy optimization as a constrained problem.\n",
        "\n",
        "$$\\max_{\\pi_{0:T}} \\mathbb{E}_{\\rho_\\pi} \\big[ \\sum_{t=0}^T r(s_t, a_t) \\big] \\text{ s.t. } \\mathbb{E}_{(s_t, a_t) \\sim \\rho_\\pi} [-\\log(\\pi_t(a_t|s_t))] \\ge H \\text{ for all } t,$$\n",
        "\n",
        "where $H$ is a desired minimum expected entropy. This constrained maximization becomes the following dual problem.\n",
        "\n",
        "$$\\min_{a_T \\ge 0} \\max_{\\pi_T} \\mathbb{E} [r(s_T, a_T) - \\alpha_T \\log \\pi(a_t|s_t)] - \\alpha_T H,$$\n",
        "\n",
        "where $\\alpha_T$ is the dual variable. Furthermore, it can be rewrited as a optimization problem with regards to $\\alpha$.\n",
        "\n",
        "$$J(\\alpha) = \\mathbb{E}_{a_t \\sim \\pi_t} [-\\alpha \\log \\pi_t (a_t | s_t) - \\alpha H].$$\n",
        "\n",
        "By optimizing this dual problem, we can adjust the dual variable $\\alpha$, which plays the role of the temperature."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FojR4ojDS7Em"
      },
      "source": [
        "## Import modules"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "e3fCpJfJS7En"
      },
      "outputs": [],
      "source": [
        "import random\n",
        "from typing import Dict, List, Tuple\n",
        "\n",
        "import gymnasium as gym\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "from IPython.display import clear_output\n",
        "from torch.distributions import Normal"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_PH3BagtS7En"
      },
      "source": [
        "## Replay buffer\n",
        "Typically, people implement replay buffers with one of the following three data structures:\n",
        "\n",
        "- collections.deque\n",
        "- list\n",
        "- numpy.ndarray\n",
        "\n",
        "**deque** is very easy to handle once you initialize its maximum length (e.g. deque(maxlen=buffer_size)). However, the indexing operation of deque gets terribly slow as it grows up because it is [internally doubly linked list](https://wiki.python.org/moin/TimeComplexity#collections.deque). On the other hands, **list** is an array, so it is relatively faster than deque when you sample batches at every step. Its amortized cost of Get item is [O(1)](https://wiki.python.org/moin/TimeComplexity#list).\n",
        "\n",
        "Last but not least, let's see **numpy.ndarray**. numpy.ndarray is even faster than list due to the fact that it is [a homogeneous array of fixed-size items](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray), so you can get the benefits of [locality of reference](https://en.wikipedia.org/wiki/Locality_of_reference), . Whereas list is an array of pointers to objects, even when all of them are of the same type.\n",
        "\n",
        "Here, we are going to implement a replay buffer using numpy.ndarray.\n",
        "\n",
        "Reference:\n",
        "- [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)\n",
        "- [rainbow-is-all-you-need](https://render.githubusercontent.com/view/ipynb?commit=032d11277cf2436853478a69ca5a4aba03202598&enc_url=68747470733a2f2f7261772e67697468756275736572636f6e74656e742e636f6d2f437572742d5061726b2f7261696e626f772d69732d616c6c2d796f752d6e6565642f303332643131323737636632343336383533343738613639636135613461626130333230323539382f30312e64716e2e6970796e62&nwo=Curt-Park%2Frainbow-is-all-you-need&path=01.dqn.ipynb&repository_id=191133946&repository_type=Repository#Replay-buffer)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "sXcgqjymS7En"
      },
      "outputs": [],
      "source": [
        "class ReplayBuffer:\n",
        "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
        "\n",
        "    def __init__(self, obs_dim: int, act_dim: int, size: int, batch_size: int = 32):\n",
        "        \"\"\"Initializate.\"\"\"\n",
        "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
        "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
        "        self.acts_buf = np.zeros([size, act_dim], dtype=np.float32)\n",
        "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
        "        self.done_buf = np.zeros([size], dtype=np.float32)\n",
        "        self.max_size, self.batch_size = size, batch_size\n",
        "        self.ptr, self.size = 0, 0\n",
        "\n",
        "    def store(\n",
        "        self,\n",
        "        obs: np.ndarray,\n",
        "        act: np.ndarray,\n",
        "        rew: float,\n",
        "        next_obs: np.ndarray,\n",
        "        done: bool,\n",
        "    ):\n",
        "        \"\"\"Store the transition in buffer.\"\"\"\n",
        "        self.obs_buf[self.ptr] = obs\n",
        "        self.next_obs_buf[self.ptr] = next_obs\n",
        "        self.acts_buf[self.ptr] = act\n",
        "        self.rews_buf[self.ptr] = rew\n",
        "        self.done_buf[self.ptr] = done\n",
        "        self.ptr = (self.ptr + 1) % self.max_size\n",
        "        self.size = min(self.size + 1, self.max_size)\n",
        "\n",
        "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
        "        \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n",
        "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
        "        return dict(\n",
        "            obs=self.obs_buf[idxs],\n",
        "            next_obs=self.next_obs_buf[idxs],\n",
        "            acts=self.acts_buf[idxs],\n",
        "            rews=self.rews_buf[idxs],\n",
        "            done=self.done_buf[idxs],\n",
        "        )\n",
        "\n",
        "    def __len__(self) -> int:\n",
        "        return self.size"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L9WsBp8uS7En"
      },
      "source": [
        "## Network\n",
        "We are going to use three different networks for policy, Q-function, and V-function. We use two Q-functions to mitigate positive bias and softly update V-function for stable learning. One interesting thing is that the policy network works as Tanh Normal distribution which enforces action bounds. (The details are descibed in Appendix C of [2].)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "HcNEGlXAS7En"
      },
      "outputs": [],
      "source": [
        "def init_layer_uniform(layer: nn.Linear, init_w: float = 3e-3) -> nn.Linear:\n",
        "    \"\"\"Init uniform parameters on the single layer.\"\"\"\n",
        "    layer.weight.data.uniform_(-init_w, init_w)\n",
        "    layer.bias.data.uniform_(-init_w, init_w)\n",
        "\n",
        "    return layer\n",
        "\n",
        "\n",
        "class Actor(nn.Module):\n",
        "    def __init__(\n",
        "        self,\n",
        "        in_dim: int,\n",
        "        out_dim: int,\n",
        "        log_std_min: float = -20,\n",
        "        log_std_max: float = 2,\n",
        "    ):\n",
        "        \"\"\"Initialize.\"\"\"\n",
        "        super(Actor, self).__init__()\n",
        "\n",
        "        # set the log std range\n",
        "        self.log_std_min = log_std_min\n",
        "        self.log_std_max = log_std_max\n",
        "\n",
        "        # set the hidden layers\n",
        "        self.hidden1 = nn.Linear(in_dim, 128)\n",
        "        self.hidden2 = nn.Linear(128, 128)\n",
        "\n",
        "        # set log_std layer\n",
        "        self.log_std_layer = nn.Linear(128, out_dim)\n",
        "        self.log_std_layer = init_layer_uniform(self.log_std_layer)\n",
        "\n",
        "        # set mean layer\n",
        "        self.mu_layer = nn.Linear(128, out_dim)\n",
        "        self.mu_layer = init_layer_uniform(self.mu_layer)\n",
        "\n",
        "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
        "        \"\"\"Forward method implementation.\"\"\"\n",
        "        x = F.relu(self.hidden1(state))\n",
        "        x = F.relu(self.hidden2(x))\n",
        "\n",
        "        # get mean\n",
        "        mu = self.mu_layer(x).tanh()\n",
        "\n",
        "        # get std\n",
        "        log_std = self.log_std_layer(x).tanh()\n",
        "        log_std = self.log_std_min + 0.5 * (self.log_std_max - self.log_std_min) * (log_std + 1)\n",
        "        std = torch.exp(log_std)\n",
        "\n",
        "        # sample actions\n",
        "        dist = Normal(mu, std)\n",
        "        z = dist.rsample()\n",
        "\n",
        "        # normalize action and log_prob\n",
        "        # see appendix C of [2]\n",
        "        action = z.tanh()\n",
        "        log_prob = dist.log_prob(z) - torch.log(1 - action.pow(2) + 1e-7)\n",
        "        log_prob = log_prob.sum(-1, keepdim=True)\n",
        "\n",
        "        return action, log_prob\n",
        "\n",
        "\n",
        "class CriticQ(nn.Module):\n",
        "    def __init__(self, in_dim: int):\n",
        "        \"\"\"Initialize.\"\"\"\n",
        "        super(CriticQ, self).__init__()\n",
        "\n",
        "        self.hidden1 = nn.Linear(in_dim, 128)\n",
        "        self.hidden2 = nn.Linear(128, 128)\n",
        "        self.out = nn.Linear(128, 1)\n",
        "        self.out = init_layer_uniform(self.out)\n",
        "\n",
        "    def forward(self, state: torch.Tensor, action: torch.Tensor) -> torch.Tensor:\n",
        "        \"\"\"Forward method implementation.\"\"\"\n",
        "        x = torch.cat((state, action), dim=-1)\n",
        "        x = F.relu(self.hidden1(x))\n",
        "        x = F.relu(self.hidden2(x))\n",
        "        value = self.out(x)\n",
        "\n",
        "        return value\n",
        "\n",
        "\n",
        "class CriticV(nn.Module):\n",
        "    def __init__(self, in_dim: int):\n",
        "        \"\"\"Initialize.\"\"\"\n",
        "        super(CriticV, self).__init__()\n",
        "\n",
        "        self.hidden1 = nn.Linear(in_dim, 128)\n",
        "        self.hidden2 = nn.Linear(128, 128)\n",
        "        self.out = nn.Linear(128, 1)\n",
        "        self.out = init_layer_uniform(self.out)\n",
        "\n",
        "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
        "        \"\"\"Forward method implementation.\"\"\"\n",
        "        x = F.relu(self.hidden1(state))\n",
        "        x = F.relu(self.hidden2(x))\n",
        "        value = self.out(x)\n",
        "\n",
        "        return value"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L0TD1zweS7Eo"
      },
      "source": [
        "## SAC Agent\n",
        "Here is a summary of SACAgent class.\n",
        "\n",
        "| Method           | Note                                                 |\n",
        "|---               |---                                                  |\n",
        "|select_action     | select an action from the input state.               |\n",
        "|step              | take an action and return the response of the env.   |\n",
        "|update_model      | update the model by gradient descent.                |\n",
        "|train             | train the agent during num_frames.                   |\n",
        "|test              | test the agent (1 episode).                          |\n",
        "|\\_target_soft_update| soft update from the local model to the target model.|\n",
        "|\\_plot              | plot the training progresses.                        |"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "CTvMz6drS7Eo"
      },
      "outputs": [],
      "source": [
        "class SACAgent:\n",
        "    \"\"\"SAC agent interacting with environment.\n",
        "\n",
        "    Attrtibutes:\n",
        "        actor (nn.Module): actor model to select actions\n",
        "        actor_optimizer (Optimizer): optimizer for training actor\n",
        "        vf (nn.Module): critic model to predict state values\n",
        "        vf_target (nn.Module): target critic model to predict state values\n",
        "        vf_optimizer (Optimizer): optimizer for training vf\n",
        "        qf_1 (nn.Module): critic model to predict state-action values\n",
        "        qf_2 (nn.Module): critic model to predict state-action values\n",
        "        qf_1_optimizer (Optimizer): optimizer for training qf_1\n",
        "        qf_2_optimizer (Optimizer): optimizer for training qf_2\n",
        "        env (gym.Env): openAI Gym environment\n",
        "        memory (ReplayBuffer): replay memory\n",
        "        batch_size (int): batch size for sampling\n",
        "        gamma (float): discount factor\n",
        "        tau (float): parameter for soft target update\n",
        "        initial_random_steps (int): initial random action steps\n",
        "        policy_update_freq (int): policy update frequency\n",
        "        device (torch.device): cpu / gpu\n",
        "        target_entropy (int): desired entropy used for the inequality constraint\n",
        "        log_alpha (torch.Tensor): weight for entropy\n",
        "        alpha_optimizer (Optimizer): optimizer for alpha\n",
        "        transition (list): temporory storage for the recent transition\n",
        "        total_step (int): total step numbers\n",
        "        is_test (bool): flag to show the current mode (train / test)\n",
        "        seed (int): random seed\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(\n",
        "        self,\n",
        "        env: gym.Env,\n",
        "        memory_size: int,\n",
        "        batch_size: int,\n",
        "        gamma: float = 0.99,\n",
        "        tau: float = 5e-3,\n",
        "        initial_random_steps: int = int(1e4),\n",
        "        policy_update_freq: int = 2,\n",
        "        seed: int = 777,\n",
        "    ):\n",
        "        \"\"\"Initialize.\"\"\"\n",
        "        obs_dim = env.observation_space.shape[0]\n",
        "        action_dim = env.action_space.shape[0]\n",
        "\n",
        "        self.env = env\n",
        "        self.memory = ReplayBuffer(obs_dim, action_dim, memory_size, batch_size)\n",
        "        self.batch_size = batch_size\n",
        "        self.gamma = gamma\n",
        "        self.tau = tau\n",
        "        self.initial_random_steps = initial_random_steps\n",
        "        self.policy_update_freq = policy_update_freq\n",
        "        self.seed = seed\n",
        "\n",
        "        # device: cpu / gpu\n",
        "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "        print(self.device)\n",
        "\n",
        "        # automatic entropy tuning\n",
        "        self.target_entropy = -np.prod((action_dim,)).item()  # heuristic\n",
        "        self.log_alpha = torch.zeros(1, requires_grad=True, device=self.device)\n",
        "        self.alpha_optimizer = optim.Adam([self.log_alpha], lr=3e-4)\n",
        "\n",
        "        # actor\n",
        "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
        "\n",
        "        # v function\n",
        "        self.vf = CriticV(obs_dim).to(self.device)\n",
        "        self.vf_target = CriticV(obs_dim).to(self.device)\n",
        "        self.vf_target.load_state_dict(self.vf.state_dict())\n",
        "\n",
        "        # q function\n",
        "        self.qf_1 = CriticQ(obs_dim + action_dim).to(self.device)\n",
        "        self.qf_2 = CriticQ(obs_dim + action_dim).to(self.device)\n",
        "\n",
        "        # optimizers\n",
        "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=3e-4)\n",
        "        self.vf_optimizer = optim.Adam(self.vf.parameters(), lr=3e-4)\n",
        "        self.qf_1_optimizer = optim.Adam(self.qf_1.parameters(), lr=3e-4)\n",
        "        self.qf_2_optimizer = optim.Adam(self.qf_2.parameters(), lr=3e-4)\n",
        "\n",
        "        # transition to store in memory\n",
        "        self.transition = list()\n",
        "\n",
        "        # total steps count\n",
        "        self.total_step = 0\n",
        "\n",
        "        # mode: train / test\n",
        "        self.is_test = False\n",
        "\n",
        "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"Select an action from the input state.\"\"\"\n",
        "        # if initial random action should be conducted\n",
        "        if self.total_step < self.initial_random_steps and not self.is_test:\n",
        "            selected_action = self.env.action_space.sample()\n",
        "        else:\n",
        "            selected_action = (\n",
        "                self.actor(torch.FloatTensor(state).to(self.device))[0].detach().cpu().numpy()\n",
        "            )\n",
        "\n",
        "        self.transition = [state, selected_action]\n",
        "\n",
        "        return selected_action\n",
        "\n",
        "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, float, bool]:\n",
        "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
        "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
        "        done = terminated or truncated\n",
        "\n",
        "        if not self.is_test:\n",
        "            self.transition += [reward, next_state, done]\n",
        "            self.memory.store(*self.transition)\n",
        "\n",
        "        return next_state, reward, done\n",
        "\n",
        "    def update_model(self) -> Tuple[torch.Tensor, ...]:\n",
        "        \"\"\"Update the model by gradient descent.\"\"\"\n",
        "        device = self.device  # for shortening the following lines\n",
        "\n",
        "        samples = self.memory.sample_batch()\n",
        "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
        "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
        "        action = torch.FloatTensor(samples[\"acts\"]).to(device)\n",
        "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
        "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
        "        new_action, log_prob = self.actor(state)\n",
        "\n",
        "        # train alpha (dual problem)\n",
        "        alpha_loss = (-self.log_alpha.exp() * (log_prob + self.target_entropy).detach()).mean()\n",
        "\n",
        "        self.alpha_optimizer.zero_grad()\n",
        "        alpha_loss.backward()\n",
        "        self.alpha_optimizer.step()\n",
        "\n",
        "        alpha = self.log_alpha.exp()  # used for the actor loss calculation\n",
        "\n",
        "        # q function loss\n",
        "        mask = 1 - done\n",
        "        q_1_pred = self.qf_1(state, action)\n",
        "        q_2_pred = self.qf_2(state, action)\n",
        "        v_target = self.vf_target(next_state)\n",
        "        q_target = reward + self.gamma * v_target * mask\n",
        "        qf_1_loss = F.mse_loss(q_1_pred, q_target.detach())\n",
        "        qf_2_loss = F.mse_loss(q_2_pred, q_target.detach())\n",
        "\n",
        "        # v function loss\n",
        "        v_pred = self.vf(state)\n",
        "        q_pred = torch.min(self.qf_1(state, new_action), self.qf_2(state, new_action))\n",
        "        v_target = q_pred - alpha * log_prob\n",
        "        vf_loss = F.mse_loss(v_pred, v_target.detach())\n",
        "\n",
        "        if self.total_step % self.policy_update_freq == 0:\n",
        "            # actor loss\n",
        "            advantage = q_pred - v_pred.detach()\n",
        "            actor_loss = (alpha * log_prob - advantage).mean()\n",
        "\n",
        "            # train actor\n",
        "            self.actor_optimizer.zero_grad()\n",
        "            actor_loss.backward()\n",
        "            self.actor_optimizer.step()\n",
        "\n",
        "            # target update (vf)\n",
        "            self._target_soft_update()\n",
        "        else:\n",
        "            actor_loss = torch.zeros(())\n",
        "\n",
        "        # train Q functions\n",
        "        self.qf_1_optimizer.zero_grad()\n",
        "        qf_1_loss.backward()\n",
        "        self.qf_1_optimizer.step()\n",
        "\n",
        "        self.qf_2_optimizer.zero_grad()\n",
        "        qf_2_loss.backward()\n",
        "        self.qf_2_optimizer.step()\n",
        "\n",
        "        qf_loss = qf_1_loss + qf_2_loss\n",
        "\n",
        "        # train V function\n",
        "        self.vf_optimizer.zero_grad()\n",
        "        vf_loss.backward()\n",
        "        self.vf_optimizer.step()\n",
        "\n",
        "        return actor_loss.data, qf_loss.data, vf_loss.data, alpha_loss.data\n",
        "\n",
        "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
        "        \"\"\"Train the agent.\"\"\"\n",
        "        self.is_test = False\n",
        "\n",
        "        state, _ = self.env.reset(seed=self.seed)\n",
        "        actor_losses, qf_losses, vf_losses, alpha_losses = [], [], [], []\n",
        "        scores = []\n",
        "        score = 0\n",
        "\n",
        "        for self.total_step in range(1, num_frames + 1):\n",
        "            action = self.select_action(state)\n",
        "            next_state, reward, done = self.step(action)\n",
        "\n",
        "            state = next_state\n",
        "            score += reward\n",
        "\n",
        "            # if episode ends\n",
        "            if done:\n",
        "                state, _ = self.env.reset(seed=self.seed)\n",
        "                scores.append(score)\n",
        "                score = 0\n",
        "\n",
        "            # if training is ready\n",
        "            if len(self.memory) >= self.batch_size and self.total_step > self.initial_random_steps:\n",
        "                losses = self.update_model()\n",
        "                actor_losses.append(losses[0].cpu().numpy())\n",
        "                qf_losses.append(losses[1].cpu().numpy())\n",
        "                vf_losses.append(losses[2].cpu().numpy())\n",
        "                alpha_losses.append(losses[3].cpu().numpy())\n",
        "\n",
        "            # plotting\n",
        "            if self.total_step % plotting_interval == 0:\n",
        "                self._plot(\n",
        "                    self.total_step, scores, actor_losses, qf_losses, vf_losses, alpha_losses\n",
        "                )\n",
        "\n",
        "        self.env.close()\n",
        "\n",
        "    def test(self, video_folder: str):\n",
        "        \"\"\"Test the agent.\"\"\"\n",
        "        self.is_test = True\n",
        "\n",
        "        tmp_env = self.env\n",
        "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
        "\n",
        "        state, _ = self.env.reset(seed=self.seed)\n",
        "        done = False\n",
        "        score = 0\n",
        "\n",
        "        while not done:\n",
        "            action = self.select_action(state)\n",
        "            next_state, reward, done = self.step(action)\n",
        "\n",
        "            state = next_state\n",
        "            score += reward\n",
        "\n",
        "        print(\"score: \", score)\n",
        "        self.env.close()\n",
        "\n",
        "        self.env = tmp_env\n",
        "\n",
        "    def _target_soft_update(self):\n",
        "        \"\"\"Soft-update: target = tau*local + (1-tau)*target.\"\"\"\n",
        "        tau = self.tau\n",
        "\n",
        "        for t_param, l_param in zip(self.vf_target.parameters(), self.vf.parameters()):\n",
        "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
        "\n",
        "    def _plot(\n",
        "        self,\n",
        "        frame_idx: int,\n",
        "        scores: List[float],\n",
        "        actor_losses: List[float],\n",
        "        qf_losses: List[float],\n",
        "        vf_losses: List[float],\n",
        "        alpha_losses: List[float],\n",
        "    ):\n",
        "        \"\"\"Plot the training progresses.\"\"\"\n",
        "\n",
        "        def subplot(loc: int, title: str, values: List[float]):\n",
        "            plt.subplot(loc)\n",
        "            plt.title(title)\n",
        "            plt.plot(values)\n",
        "\n",
        "        subplot_params = [\n",
        "            (151, f\"frame {frame_idx}. score: {np.mean(scores[-10:])}\", scores),\n",
        "            (152, \"actor_loss\", actor_losses),\n",
        "            (153, \"qf_loss\", qf_losses),\n",
        "            (154, \"vf_loss\", vf_losses),\n",
        "            (155, \"alpha_loss\", alpha_losses),\n",
        "        ]\n",
        "\n",
        "        clear_output(True)\n",
        "        plt.figure(figsize=(30, 5))\n",
        "        for loc, title, values in subplot_params:\n",
        "            subplot(loc, title, values)\n",
        "        plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c0WnqETrS7Eo"
      },
      "source": [
        "## Environment\n",
        "*ActionNormalizer* is an action wrapper class to normalize the action values ranged in (-1. 1). Thanks to this class, we can make the agent simply select action values within the zero centered range (-1, 1)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "HL38kI6VS7Ep"
      },
      "outputs": [],
      "source": [
        "class ActionNormalizer(gym.ActionWrapper):\n",
        "    \"\"\"Rescale and relocate the actions.\"\"\"\n",
        "\n",
        "    def action(self, action: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"Change the range (-1, 1) to (low, high).\"\"\"\n",
        "        low = self.action_space.low\n",
        "        high = self.action_space.high\n",
        "\n",
        "        scale_factor = (high - low) / 2\n",
        "        reloc_factor = high - scale_factor\n",
        "\n",
        "        action = action * scale_factor + reloc_factor\n",
        "        action = np.clip(action, low, high)\n",
        "\n",
        "        return action\n",
        "\n",
        "    def reverse_action(self, action: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"Change the range (low, high) to (-1, 1).\"\"\"\n",
        "        low = self.action_space.low\n",
        "        high = self.action_space.high\n",
        "\n",
        "        scale_factor = (high - low) / 2\n",
        "        reloc_factor = high - scale_factor\n",
        "\n",
        "        action = (action - reloc_factor) / scale_factor\n",
        "        action = np.clip(action, -1.0, 1.0)\n",
        "\n",
        "        return action"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0evw_aXBS7Ep"
      },
      "source": [
        "You can see [the code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/pendulum.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/e73245912087d47b538dcdb45fa9a9d185b805c5/gymnasium/envs/__init__.py#L41) of Pendulum-v1 from Gymnasyim repository."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "p00CjqEdS7Ep"
      },
      "outputs": [],
      "source": [
        "# environment\n",
        "env = gym.make(\"Pendulum-v1\", render_mode=\"rgb_array\")\n",
        "env = ActionNormalizer(env)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q7E6c6oNS7Ep"
      },
      "source": [
        "## Set random seed"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "ELvvT4DtS7Ep"
      },
      "outputs": [],
      "source": [
        "def seed_torch(seed):\n",
        "    torch.manual_seed(seed)\n",
        "    if torch.backends.cudnn.enabled:\n",
        "        torch.backends.cudnn.benchmark = False\n",
        "        torch.backends.cudnn.deterministic = True\n",
        "\n",
        "\n",
        "seed = 777\n",
        "random.seed(seed)\n",
        "np.random.seed(seed)\n",
        "seed_torch(seed)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o2SjQatgS7Ep"
      },
      "source": [
        "## Initialize"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WXW9gUDcS7Ep",
        "outputId": "c28bce43-8acc-4604-8ba9-73104acba71d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ],
      "source": [
        "# parameters\n",
        "num_frames = 50000\n",
        "memory_size = 100000\n",
        "batch_size = 128\n",
        "initial_random_steps = 10000\n",
        "\n",
        "agent = SACAgent(env, memory_size, batch_size, initial_random_steps=initial_random_steps, seed=seed)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PJnjLFJdS7Eq"
      },
      "source": [
        "## Train"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 318
        },
        "id": "4znPLvs8S7Eq",
        "outputId": "a61cb17e-db89-46c3-8864-25aab96f5399"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 3000x500 with 5 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAACWUAAAHDCAYAAABGA+oNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hTZfsH8G9W012gtJRRSgFlD0WEgjIUKQgqylBEtriKypClvsgQKiIiMkV9gZ+CbNAXEChTkCEge6+y2zK7mzQ5z++PktOcJG3T0jYd38915WrynOecc6dtcpKTO/etEkIIEBERERERERERERERERERERERUb5QuzoAIiIiIiIiIiIiIiIiIiIiIiKikoRJWURERERERERERERERERERERERPmISVlERERERERERERERERERERERET5iElZRERERERERERERERERERERERE+YhJWURERERERERERERERERERERERPmISVlERERERERERERERERERERERET5iElZRERERERERERERERERERERERE+YhJWURERERERERERERERERERERERPmISVlERERERERERERERERERERERET5iElZBejAgQNo0aIFvLy8oFKpcOTIEVeHREREREQl1I4dO6BSqbBjxw5Xh0JERORyJpMJI0eORHBwMNRqNbp06eLUev369UO1atUKNDYiIqKSbOPGjWjcuDHc3d2hUqnw4MGDHNfh+1kiIqIMj3JMtKy7cuXK/A8sC9HR0VCpVFi4cGGh7ZOouGFSVgFJT09H9+7dce/ePUyfPh2//PILQkJCXB1WvujXrx9UKpXdpXbt2nZzJUnC119/jdDQULi7u6Nhw4b47bffHG739OnT6NChA7y9vVGuXDn07t0bt2/fLpRtUvbmzp2L7t27o2rVqlCpVOjXr5/DeVu3bsWAAQPw+OOPw9PTE9WrV8fbb7+NW7duZbv9Bw8eIDAwMNcvFGJjY/Huu++icuXKcHd3R7Vq1TBw4EDFnNWrV+P1119H9erV4enpiVq1amH48OEOTwakpaUhMjISdevWhaenJypXrozu3bvj5MmTdnMPHTqEzp07IygoCN7e3mjYsCG+//57mM1mxbykpCQMGTIEVapUgV6vR506dTB37lyH98fZbQJAYmIiRo4cidDQUOj1elSuXBndunVDSkpKlr+vQYMGQaVSoXPnzorxu3fvYurUqWjVqhUCAgJQpkwZNG/eHMuWLXO4HYPBgFGjRqFSpUrw8PBAs2bNEBUVleV+gez/xlk9p1guN27ckOdu3rwZAwcORP369aHRaLL8sOTMmTMYOXIkGjduDB8fH1SsWBGdOnXCwYMHs42TiOhR3Lx5E+PGjWMiPhERURHw3//+F1OnTkW3bt2waNEiDB061NUhERERlXh3795Fjx494OHhgdmzZ+OXX36Bl5eXq8MiIiIiInIZrasDKKkuXryIK1eu4Mcff8Tbb7/t6nDynV6vx08//aQY8/Pzs5v32Wef4auvvsKgQYPQtGlT/P7773jzzTehUqnwxhtvyPOuX7+OVq1awc/PD5MnT0ZSUhK++eYbHD9+HP/88w/c3NwKdJuUvSlTpiAxMRFPP/10tglWo0aNwr1799C9e3c89thjuHTpEmbNmoV169bhyJEjCAoKcrje2LFjs00mcuTatWto2bIlAOC9995D5cqVcfPmTfzzzz+Kee+88w4qVaqEt956C1WrVsXx48cxa9YsbNiwAf/++y88PDzkub169cIff/yBQYMG4cknn8TNmzcxe/ZshIWF4fjx43Ji5aFDh9CiRQs89thjGDVqFDw9PfHnn3/i448/xsWLFzFjxgwAgNlsRnh4OA4ePIiIiAg89thj2LRpEz744APcv38fn376qbxvZ7cJAPHx8WjdujWuX7+Od955BzVr1sTt27exa9cuGAwGeHp62v2+Dh48iIULF8Ld3d1u2d69e/HZZ5/hxRdfxOeffw6tVotVq1bhjTfewKlTpzB+/HjF/H79+mHlypUYMmQIHnvsMSxcuBAvvvgitm/fjmeeecbh3yu7v/G7776Ldu3aKcaEEHjvvfdQrVo1VK5cWR5fsmQJli1bhieffBKVKlVyuD0A+Omnn/Dzzz+ja9eu+OCDDxAfH48ffvgBzZs3x8aNG+32R0SUH27evInx48ejWrVqaNy4savDISIiKtW2bduGypUrY/r06a4OhYiIqNQ4cOAAEhMTMXHiRJ5/IyIiIiICAEEFYufOnQKAWLFiRY5zk5KSCiGi/NO3b1/h5eWV47zr168LnU4nIiIi5DFJksSzzz4rqlSpIkwmkzz+/vvvCw8PD3HlyhV5LCoqSgAQP/zwQ4FusziRJEmkpKQU+n6jo6OFJElCCCG8vLxE3759Hc7buXOnMJvNdmMAxGeffeZwnePHjwutVismTJjg9GNGCCE6duwoQkNDxZ07d7Kdt337druxRYsWCQDixx9/lMeuX78uAIhPPvlEMXfbtm0CgPj222/lsUGDBgk3Nzdx9+5dxdxWrVoJX19f+fby5csFAPHzzz8r5nXt2lW4u7uL2NjYXG9TiIz/7TJlyohLly5le98tJEkSYWFhYsCAASIkJER06tRJsfzSpUsiOjrabp3nnntO6PV6xXPU/v37BQAxdepUeSw1NVXUqFFDhIWFOdx/Xv7Gu3btEgDEpEmTFOM3btwQRqNRCCFEp06dREhIiMP1Dx48KBITExVjd+7cEQEBAaJly5Y57p+IKC8OHDggAIgFCxbk63adfa24fft2AcDhsY+IiKi0adu2rahXr16u1+vbt2+W7zOIiIgoe5bzrgcOHMjVenw/S0RElOFRjomWdZ39rDU/XL58uUDOiROVJGxfWAD69euH1q1bAwC6d+8OlUqFNm3ayMu8vb1x8eJFvPjii/Dx8UGvXr0AALt27ZJbxOn1egQHB2Po0KFITU212763tzeuXr2Kzp07w9vbG5UrV8bs2bMBAMePH8dzzz0HLy8vhISEYMmSJXYxPnjwAEOGDEFwcDD0ej1q1qyJKVOmQJIkp++n2WxGQkJClst///13pKen44MPPpDHVCoV3n//fVy/fh179+6Vx1etWoXOnTujatWq8li7du3w+OOPY/ny5QW6zdw4ePAgwsPDUb58eXh4eCA0NBQDBgxQzJEkCTNmzECDBg3g7u6OgIAAdOjQQdE2zWQyYeLEiahRowb0ej2qVauGTz/9FAaDQbGtatWqoXPnzti0aROeeuopeHh44IcffgDg/N/w1q1bOHPmDNLT0/N0nwEgJCQEKpUqx3mtWrWCWq22GytXrhxOnz7tcJ2PP/4Yr776Kp599lmn4zlz5gz+/PNPjBgxAv7+/khLS8vy/lkee9ZeffVVAFDElJiYCACoUKGCYm7FihUBQFFRKyEhAe7u7ihTpozdXOt5u3btAgBFBTfL7bS0NPz++++53uaDBw+wYMECvPPOOwgNDYXRaLT7v7H1yy+/4MSJE5g0aZLD5aGhoXbtVVUqFbp06QKDwYBLly7J4ytXroRGo8E777wjj7m7u2PgwIHYu3cvrl27Zrf9vPyNlyxZApVKhTfffFMxXqlSJeh0uhzXb9KkCby9vRVj/v7+ePbZZ7P8XySi0unKlSv44IMPUKtWLXh4eMDf3x/du3dHdHS03dwHDx5g6NChqFatGvR6PapUqYI+ffrgzp072LFjB5o2bQoA6N+/v9yCdeHChfL6K1asQJMmTeDh4YHy5cvjrbfeUrRoBbJ/rZhXzuw3JiYG/fv3l9vtVqxYEa+88ori9+DM6yAiIqLCsHv3bjRt2hTu7u6oUaMGfvjhB4wbNw4qlQrR0dFQqVTYvn07Tp48KR+Td+zYkef9JScnY/jw4fL771q1auGbb76BEEIxLyoqCs888wzKlCkDb29v1KpVS1EhGQBmzpyJevXqwdPTE2XLlsVTTz3l8LwNERFRUbJy5UqoVCrs3LnTbtkPP/wAlUqF8uXLo2/fvgCApk2bQqVSoV+/fo+0X76fJSKikiI356FttWnTBvXr15e77liOZfPmzXM4X5IkTJo0CVWqVIG7uzuef/55XLhwQTHH2byEvNq2bRueffZZeHl5oUyZMnjllVfsPp9LTEzEkCFD5PPtgYGBeOGFF/Dvv//Kc86fP4+uXbsiKCgI7u7uqFKlCt544w3Ex8fnS5xEhYHtCwvAu+++i8qVK2Py5Mn46KOP0LRpU0Wih8lkQnh4OJ555hl88803cquxFStWICUlBe+//z78/f3xzz//YObMmbh+/TpWrFih2IfZbEbHjh3RqlUrfP3111i8eDEGDx4MLy8vfPbZZ+jVqxdee+01zJs3D3369EFYWBhCQ0MBACkpKWjdujVu3LiBd999F1WrVsWePXswZswY3Lp1C999912O9zElJQW+vr5ISUlB2bJl0bNnT0yZMkWRBHH48GF4eXmhTp06inWffvppefkzzzyDGzduIC4uDk899ZTdfp5++mls2LChQLfprLi4OLRv3x4BAQEYPXo0ypQpg+joaKxevVoxb+DAgVi4cCE6duyIt99+GyaTCbt27cK+ffvkeN5++20sWrQI3bp1w/Dhw7F//35ERkbi9OnTWLNmjWJ7Z8+eRc+ePfHuu+9i0KBBqFWrVq7+hmPGjMGiRYtw+fJlVKtWLdf3+1ElJSUhKSkJ5cuXt1u2YsUK7NmzB6dPn3bqRYfFli1bAGQkUD3//PPYtm0bNBoNXnjhBcydOzfH+xkTEwMAiphq1KiBKlWqYNq0aahVqxaeeOIJ3Lx5EyNHjkRoaKgisapNmzZYtmwZ3n33XQwbNkxuNbh69WpMnTpVnmcwGKDRaOxaZVoe84cOHcKgQYNytc3du3cjLS0NNWvWRLdu3bB27VpIkoSwsDDMnj3brl1WYmIiRo0ahU8//TTL9pG5+T0dPnwYjz/+OHx9fRVzLY/BI0eOIDg4WB7Py984PT0dy5cvR4sWLfL9fzYmJsbh/yIRlV4HDhzAnj178MYbb6BKlSqIjo7G3Llz0aZNG5w6dUp+zk5KSpITOwcMGIAnn3wSd+7cwR9//IHr16+jTp06mDBhAsaOHYt33nlHTkRt0aIFAGDhwoXo378/mjZtisjISMTGxmLGjBn4+++/cfjwYUVSblavFfPC2f127doVJ0+exIcffohq1aohLi4OUVFRuHr1qnzbmddBREREBe348ePyMWncuHEwmUz44osv5PMuAQEB+OWXXzBp0iQkJSUhMjISAOzOIzhLCIGXX34Z27dvx8CBA9G4cWNs2rQJI0aMwI0bN+T2iCdPnkTnzp3RsGFDTJgwAXq9HhcuXMDff/8tb+vHH3/ERx99hG7duuHjjz9GWloajh07hv3799t9IYWIiKgo6dSpE7y9vbF8+XL5C+kWy5YtQ7169TB9+nSsXLkS8+fPx4QJExAaGooaNWrkeZ98P0tERCWJs+ehs3L//n28+OKL6NGjB3r27Inly5fj/fffh5ubm12i8VdffQW1Wo1PPvkE8fHx+Prrr9GrVy/s379fnpObvITc2rJlCzp27Ijq1atj3LhxSE1NxcyZM9GyZUv8+++/8md/7733HlauXInBgwejbt26uHv3Lnbv3o3Tp0/jySefhNFoRHh4OAwGAz788EMEBQXhxo0bWLduHR48eAA/P79HipOo0Li6VFdJlVV5wL59+woAYvTo0XbrOGpLFxkZKVQqlaIFn2UbkydPlsfu378vPDw8hEqlEkuXLpXHz5w5IwCIL774Qh6bOHGi8PLyEufOnVPsa/To0UKj0YirV69me99Gjx4tRo0aJZYtWyZ+++03OZ6WLVuK9PR0eV6nTp1E9erV7dZPTk5W/A4srX7+7//+z27uiBEjBACRlpZWYNt01po1a3IsvWxpdffRRx/ZLbO0/zty5IgAIN5++23F8k8++UQAENu2bZPHQkJCBACxceNGxdzc/A0tf5/Lly87fV+zk137QkcmTpwoAIitW7cqxlNSUkTVqlXFmDFjhBC5K6n50UcfCQDC399fdOjQQSxbtkxMnTpVeHt7ixo1aojk5ORs1x84cKDQaDR2v7/9+/eLGjVqCADypUmTJuLWrVuKeSaTSQwePFjodDp5nkajEXPnzlXMmzZtmgAgdu3apRgfPXq0ACA6d+6c621+++238n1/+umnxeLFi8WcOXNEhQoVRNmyZcXNmzcV8z/55BMRGhoq/787al/oyN27d0VgYKB49tlnFeP16tUTzz33nN38kydPCgBi3rx58lhe/8b/+9//BAAxZ86cbOdl177Qkb/++kuoVCrxn//8x+l1iKjkc/T6a+/evXavI8aOHSsAiNWrV9vNtxzjs2pfaDQaRWBgoKhfv75ITU2Vx9etWycAiLFjx8pj2b1WzIltaWtn93v//n271rS2nHkdREREVBi6dOki3N3dFedJTp06JTQajbA+zdW6det8aV+4du1aAUB8+eWXinndunUTKpVKXLhwQQghxPTp0wUAcfv27Sy3/corr+QpJiIioqKgZ8+eIjAwUJhMJnns1q1bQq1WiwkTJgghhFiwYEG+tC/k+1kiIippnD0P7ah9YevWrQUAMW3aNHnMYDCIxo0bi8DAQGE0GhXr1qlTRxgMBnnujBkzBABx/PjxbONxlJeQE0ftCy1x3b17Vx47evSoUKvVok+fPvKYn5+fiIiIyHLbhw8fLvR2jEQFge0LXeT999+3G7NuUZacnIw7d+6gRYsWEELg8OHDdvPffvtt+XqZMmVQq1YteHl5oUePHvJ4rVq1UKZMGUX7sRUrVuDZZ59F2bJlcefOHfnSrl07mM1m/PXXX9nGHhkZia+++go9evTAG2+8gYULF2LSpEn4+++/sXLlSnleamoq9Hq93fru7u7ycuufzs7N7206y/LNm3Xr1mXZKm/VqlVQqVT44osv7JZZ2v9ZqnQNGzZMsXz48OEAgPXr1yvGQ0NDER4erhjLzd9w4cKFEEK4pErWX3/9hfHjx6NHjx547rnnFMu++uorpKen27VycEZSUhIAICgoCOvXr0ePHj3wySef4Mcff8TFixezbf2wZMkS/Pzzzxg+fDgee+wxxbKyZcuicePGGD16NNauXYtvvvkG0dHR6N69O9LS0uR5Go0GNWrUQHh4OBYtWoRly5bhpZdewocffoi1a9fK89588034+flhwIABiIqKQnR0NObPn485c+YAUP4POrtNy31XqVTYunUr3nzzTbz//vtYu3Yt7t+/L7cxBYBz585hxowZmDp1qsPHQlYkSUKvXr3w4MEDzJw5U7HM2ccgkPe/8ZIlS6DT6RTPZY8qLi4Ob775JkJDQzFy5Mh82y4RFX/Wr7/S09Nx9+5d1KxZE2XKlFGUSV61ahUaNWokt8C1llOL34MHDyIuLg4ffPCB/HwJZHzTuHbt2nbHfsDxa8Xccna/Hh4ecHNzw44dO3D//n2H23LmdRAREVFBM5vN2LRpE7p06YKqVavK43Xq1LF735xfNmzYAI1Gg48++kgxPnz4cAgh8OeffwLIPFb+/vvvkCTJ4bbKlCmD69ev48CBAwUSKxERUUF6/fXXERcXp2gJvHLlSkiShNdffz1f98X3s0REVNI4ex46K1qtFu+++658283NDe+++y7i4uJw6NAhxdz+/fsruvhYujpY5wvkNi/BWbdu3cKRI0fQr18/lCtXTh5v2LAhXnjhBUU3qzJlymD//v24efOmw21ZKmFt2rQJKSkpeY6JyNWYlOUCWq0WVapUsRu/evWq/ATl7e2NgIAAuRSwbV9Ud3d3BAQEKMb8/PxQpUoVuw8G/fz8FG9Izp8/j40bNyIgIEBxadeuHYCM5IXcGjp0KNRqtdxWDsh4MjcYDHZzLcktlid7y09n5+b3Np3VunVrdO3aFePHj0f58uXxyiuvYMGCBYp9XLx4EZUqVVIcZGxduXIFarUaNWvWVIwHBQWhTJkyuHLlimLc0nbSWkH8DW/fvo2YmBj5Ykn+yaszZ87g1VdfRf369fHTTz8plkVHR2Pq1KmYNGmSouWlsyx/ux49ekCtznwa6969O7RaLfbs2eNwvV27dmHgwIEIDw/HpEmTFMvi4+Px7LPPIiwsDJGRkXjllVcwfPhwrFq1Crt378aCBQvkuV999RWmTJmC3377DX369EGPHj2wZs0aPPPMM4iIiIDJZAKQ8Tf9448/YDAY0L59e4SGhmLEiBFyopP1fXd2m5b7/tJLLynWb968OUJDQxX3/eOPP0aLFi3QtWvXXP1+P/zwQ2zcuBE//fQTGjVqpFjm7GMwr3/jpKQk/P777wgPD4e/v3+u4s5KcnIyOnfujMTERPz+++95+p8jopIrNTUVY8eORXBwMPR6PcqXL4+AgAA8ePBA8frr4sWLqF+/fp72YTm216pVy25Z7dq17Y79Wb1WLKj96vV6TJkyBX/++ScqVKggt8e2tLEFnHsdREREVNBu376N1NRUuy/YAI6Pd/nhypUrqFSpEnx8fBTjlnaIluPp66+/jpYtW+Ltt99GhQoV8MYbb2D58uWKBK1Ro0bB29sbTz/9NB577DFEREQo2hsSEREVZR06dICfnx+WLVsmjy1btgyNGzfG448/nq/74vtZIiIqaZw9D52VSpUqwcvLSzFmOf5GR0crxq2/xARkFKUAoMgXyE1eQm5kdwyvU6cO7ty5g+TkZADA119/jRMnTiA4OBhPP/00xo0bp0gcCw0NxbBhw/DTTz+hfPnyCA8Px+zZsx8pPiJXYFKWC+j1ekUiCZDxbc8XXngB69evx6hRo7B27VpERUVh4cKFAGD3LUuNRuNw21mNCyHk65Ik4YUXXkBUVJTDS24TOICMRAx/f3/cu3dPHqtYsSJiYmIU+wYyMmSBjIOHZZ71uO3ccuXKyZV5CmKbzlKpVFi5ciX27t2LwYMH48aNGxgwYACaNGmSpwSmnKpqWDhKHiuIv2HTpk1RsWJF+fLNN9/kehsW165dQ/v27eHn54cNGzbYnbweO3YsKleujDZt2iA6OhrR0dHyG+Xbt28jOjo6y28WA5l/5woVKijGNRoN/P39HX4r6ujRo3j55ZdRv359rFy5ElqtVrF81apViI2Nxcsvv6wYb926NXx9fRUnyufMmYPnnnvOLrnn5Zdfxs2bNxUvflq1aoVLly7h8OHD2L17N27cuIHmzZsDgOJkhbPbzOq+A0BgYKB837dt24aNGzfi448/ln/H0dHRMJlMSE1NRXR0NBISEuy2MX78eMyZMwdfffUVevfubbe8YsWKWT6urOPL69947dq1SElJQa9eveyW5YXRaMRrr72GY8eO4ffff89zQgURlVwffvghJk2ahB49emD58uXYvHkzoqKi4O/vn+2xqCA5eq1Y0IYMGYJz584hMjIS7u7u+M9//oM6derI34rK79dBREREJY2Hhwf++usvbNmyBb1798axY8fw+uuv44UXXoDZbAaQcQL67NmzWLp0KZ555hmsWrUKzzzzjMNq20REREWNXq9Hly5dsGbNGphMJty4cQN///13vlfJyi2+nyUiouKgMM9D55QvkNu8hILSo0cPXLp0CTNnzkSlSpUwdepU1KtXT65IDQDTpk3DsWPH8OmnnyI1NRUfffQR6tWrh+vXrxdKjET5QZvzFCoMx48fx7lz57Bo0SL06dNHHo+Kisr3fdWoUQNJSUlyVaX8kJiYiDt37iiqdzVu3Bg//fQTTp8+jbp168rj+/fvl5cDQOXKlREQEICDBw/abfeff/6R5xXUNnOrefPmaN68OSZNmoQlS5agV69eWLp0Kd5++23UqFEDmzZtwr1797KslhUSEgJJknD+/Hn5m7UAEBsbiwcPHiAkJCTHGArib7h48WJF67nq1avnaTt3795F+/btYTAYsHXrVjlBztrVq1dx4cIFh/v44IMPAGRka1tKS9tq0qQJAODGjRuKcaPRaPd/CGRUN+nQoQMCAwOxYcMGh5WSYmNjAUA+WW4hhIDZbJYrVVnm2s4DIJe/tp4LZLz4sf6fs1SUs/77ObvNrO47ANy8eRO1a9cGkPE7BoDXXnvNbt6NGzcQGhqK6dOnY8iQIfL47NmzMW7cOAwZMgSjRo2yWw/IeIxt374dCQkJ8PX1lcdtH4N5/RsvXrwY3t7edslxeSFJEvr06YOtW7di+fLlcoY/EZG1lStXom/fvpg2bZo8lpaWhgcPHijm1ahRAydOnMh2W1klXFuO7WfPnrVr53v27Fmnjv15kdv91qhRA8OHD8fw4cNx/vx5NG7cGNOmTcOvv/4qz8nudRAREVFBCwgIgIeHB86fP2+37OzZswWyz5CQEGzZsgWJiYmKLxydOXNGXm6hVqvx/PPP4/nnn8e3336LyZMn47PPPsP27dvl939eXl54/fXX8frrr8tfIpk0aRLGjBmjaM9ERERUFL3++utYtGgRtm7ditOnT0MIUSBJWXw/S0REJY2z56GzcvPmTSQnJyuqZZ07dw4AUK1atVzFUpB5CdbHcFtnzpxB+fLlFfehYsWK+OCDD/DBBx8gLi4OTz75JCZNmoSOHTvKcxo0aIAGDRrg888/x549e9CyZUvMmzcPX3755SPHS1QYWCmriLBkrFpXgBJCYMaMGfm+rx49emDv3r3YtGmT3bIHDx7YJZRYS0tLQ2Jiot34xIkTIYRAhw4d5LFXXnkFOp0Oc+bMkceEEJg3bx4qV66MFi1ayONdu3bFunXrcO3aNXls69atOHfuHLp3716g20xPT8eZM2ccVv+xdv/+fbsKXZYEFEup465du0IIgfHjx9utb1n3xRdfBAB89913iuXffvstAKBTp07ZxgHk7m9469YtnDlzRk7uyUrLli3Rrl07+ZKXpKzk5GS8+OKLuHHjBjZs2OCwpQQAfPnll1izZo3iMnHiRADAyJEjsWbNGvmAnJKSgjNnzuDOnTvy+m3atEFgYCAWL14st80DgIULF8rZ3RYxMTFo37491Go1Nm3aZJewZWGpWrV06VLF+B9//IHk5GQ88cQTirlRUVG4e/euPGY2m7F8+XL4+PigRo0aWf6Obt++jSlTpqBhw4aKpCxnt1mrVi00atQIv//+u+J3snnzZly7dk2+788995zd73jNmjUICAjAU089hTVr1uCll16S11+2bBk++ugj9OrVS/5fdKRbt24wm82YP3++PGYwGLBgwQI0a9YMwcHBAHL3N7b+3WzZsgWvvvoqPD09s4zBWR9++CGWLVuGOXPmOExOIyICMl6D2R7fZ86caZco27VrVxw9ehRr1qyx24Zlfcvzmu0b6aeeegqBgYGYN2+eoj3Cn3/+idOnTzt17M8LZ/ebkpKiOJ4CGSe0fXx85PWceR1ERERU0DQaDcLDw7F27Vr5iygAcPr0aYfvj/PDiy++CLPZjFmzZinGp0+fDpVKJZ8otq4cbmF7rLR+vwcAbm5uqFu3LoQQOb5nJyIiKgratWuHcuXKYdmyZVi2bBmefvpphIaG5vt++H6WiIhKGmfPQ2fFZDLhhx9+kG8bjUb88MMPCAgIkAs65CYWoGDyEipWrIjGjRtj0aJFivPkJ06cwObNm+XPyc1ms10bwsDAQFSqVEk+PickJNjlLTRo0ABqtZrHcCpWWCmriKhduzZq1KiBTz75BDdu3ICvry9WrVrlsA3boxoxYgT++OMPdO7cGf369UOTJk2QnJyM48ePY+XKlYiOjkb58uUdrhsTE4MnnngCPXv2lCvybNq0CRs2bECHDh3wyiuvyHOrVKmCIUOGYOrUqUhPT0fTpk2xdu1a7Nq1C4sXL1aUTvz000+xYsUKtG3bFh9//DGSkpIwdepUNGjQAP379y/Qbd64cQN16tRB37595bKMjixatAhz5szBq6++iho1aiAxMRE//vgjfH195QNI27Zt0bt3b3z//fc4f/48OnToAEmSsGvXLrRt2xaDBw9Go0aN0LdvX8yfPx8PHjxA69at8c8//2DRokXo0qUL2rZtm69/wzFjxmDRokW4fPlyrjOlLf73v//h6NGjADKS2I4dOyZnH7/88sto2LAhAKBXr174559/MGDAAJw+fRqnT5+Wt+Ht7Y0uXboAAJ555hm7fVgqJjVt2lSeB2RUNmvbti2++OILjBs3DkBGqeypU6eib9++aNWqFXr37o2rV69ixowZePbZZxUJOB06dMClS5cwcuRI7N69G7t375aXVahQQU5ieumll1CvXj1MmDABV65cQfPmzXHhwgXMmjULFStWxMCBA+X1Ro8ejbfeegvNmjXDO++8Aw8PD/z22284dOgQvvzyS+h0Onlu69atERYWhpo1ayImJgbz589HUlIS1q1bp2hNlZttTp8+HS+88AKeeeYZvPvuu4iPj8e3336Lxx9/HO+//z6AjH7Rtj2jgYxy3hUqVLD7Hffp0wf+/v54/vnnsXjxYsU6LVq0kJP0mjVrhu7du2PMmDGIi4tDzZo1sWjRIkRHR+Pnn3+W18nN39hi2bJlMJlM2bYuPHbsGP744w8AwIULFxAfHy//LzZq1EhONPvuu+8wZ84chIWFwdPTU/GtOAB49dVX7ZLCiKh06ty5M3755Rf4+fmhbt262Lt3L7Zs2QJ/f3/FvBEjRmDlypXo3r273Obg3r17+OOPPzBv3jw0atQINWrUQJkyZTBv3jz4+PjAy8sLzZo1Q2hoKKZMmYL+/fujdevW6NmzJ2JjYzFjxgxUq1YNQ4cOLZD7ptPpnNrvuXPn8Pzzz6NHjx6oW7cutFot1qxZg9jYWLzxxhsAnHsdREREVBjGjx+PjRs34tlnn8UHH3wAk8mEmTNnol69ejh27Fi+7++ll15C27Zt8dlnnyE6OhqNGjXC5s2b8fvvv2PIkCHyF2gmTJiAv/76C506dUJISAji4uIwZ84cVKlSRX5/1L59ewQFBaFly5aoUKECTp8+jVmzZqFTp06KKlxERERFlU6nw2uvvYalS5ciOTkZ33zzTYHth+9niYioJHH2PHRWKlWqhClTpiA6OhqPP/44li1bhiNHjmD+/PmKzxCdUdB5CVOnTkXHjh0RFhaGgQMHIjU1FTNnzoSfn5/8WW9iYiKqVKmCbt26oVGjRvD29saWLVtw4MABuZrYtm3bMHjwYHTv3h2PP/44TCYTfvnlF2g0GnTt2jVfYiUqFIIKxPbt2wUAsWLFCsV43759hZeXl8N1Tp06Jdq1aye8vb1F+fLlxaBBg8TRo0cFALFgwYIct9G6dWtRr149u/GQkBDRqVMnxVhiYqIYM2aMqFmzpnBzcxPly5cXLVq0EN98840wGo1Z3q/79++Lt956S9SsWVN4enoKvV4v6tWrJyZPnuxwPbPZLCZPnixCQkKEm5ubqFevnvj1118dbvvEiROiffv2wtPTU5QpU0b06tVLxMTEFPg2L1++LACIvn37Znm/hRDi33//FT179hRVq1YVer1eBAYGis6dO4uDBw8q5plMJjF16lRRu3Zt4ebmJgICAkTHjh3FoUOH5Dnp6eli/PjxIjQ0VOh0OhEcHCzGjBkj0tLSFNty9LezcPZv2LdvXwFAXL58Odv7lx3LNhxdrP83Q0JCspwXEhKS7T6yesxYxr/44gu7dX777TfRqFEjodfrRYUKFcTgwYNFQkKCYk5W8QAQrVu3Vsy9d++eGDp0qHj88ceFXq8X5cuXF2+88Ya4dOmS3b43btwoWrduLcqXLy/c3NxEgwYNxLx58+zmDR06VFSvXl3o9XoREBAg3nzzTXHx4kWHvwNntymEEFFRUaJ58+bC3d1dlCtXTvTu3VvcunXL4Vxrjv6nFixYkO3vyfpvLIQQqamp4pNPPhFBQUFCr9eLpk2bio0bN+a476z+xhbNmzcXgYGBwmQyZbmN7GK1fgxn9z/7qI8HIipZ7t+/L/r37y/Kly8vvL29RXh4uDhz5owICQmxe21w9+5dMXjwYFG5cmXh5uYmqlSpIvr27Svu3Lkjz/n9999F3bp1hVartXsOXbZsmXjiiSeEXq8X5cqVE7169RLXr19X7CO714o5sTzPbt++XTGe037v3LkjIiIiRO3atYWXl5fw8/MTzZo1E8uXL5fnOPs6iIiIqDDs3LlTNGnSRLi5uYnq1auLefPmiS+++EJYn+bK6hxJTvr27Wv3/jUxMVEMHTpUVKpUSeh0OvHYY4+JqVOnCkmS5Dlbt24Vr7zyiqhUqZJwc3MTlSpVEj179hTnzp2T5/zwww+iVatWwt/fX+j1elGjRg0xYsQIER8fn/tfAhERkYtERUUJAEKlUolr164pllnO3R04cCBX2+T7WSIiKumcPQ/t6JhoeX978OBBERYWJtzd3UVISIiYNWuWYh9ZfQ5n+Szc+ly1s3kJOXG0bSGE2LJli2jZsqXw8PAQvr6+4qWXXhKnTp2SlxsMBjFixAjRqFEj4ePjI7y8vESjRo3EnDlz5DmXLl0SAwYMEDVq1JA/D23btq3YsmWL0/ERFQUqIWzq5BERERERERERERUj48aNw/jx4+3aQRAREREREREVZ23atMGdO3dw4sQJV4dCRHmgznkKEREREREREREREREREREREREROUvr6gCIiIiIiChrqampiI+Pz3ZOuXLl4ObmVkgRERERFT/37t2D0WjMcrlGo0FAQEAhRkRERFTy8f0sERFR8WQ0GnHv3r1s5/j5+cHDw6OQIiIqvpiURURERERUhC1btgz9+/fPds727dvRpk2bwgmIiIioGHrttdewc+fOLJeHhIQgOjq68AIiIiIqBfh+loiIqHjas2cP2rZtm+2cBQsWoF+/foUTEFExphJCCFcHQUREREREjt26dQsnT57Mdk6TJk1QtmzZQoqIiIio+Dl06BDu37+f5XIPDw+0bNmyECMiIiIq+fh+loiIqHi6f/8+Dh06lO2cevXqoWLFioUUEVHxxaQsIiIiIiIiIiIiIiIiIiIiIiKifKR2dQBEREREREREREREREREREREREQlidbVARQFkiTh5s2b8PHxgUqlcnU4RERUjAghkJiYiEqVKkGtZq5zXvA4TEREecFj8KPjMZiIiPKCx+BHx2MwERHlRWk/BkdGRmL16tU4c+YMPDw80KJFC0yZMgW1atVyehs8BhMRUV48yjGY7QsBXL9+HcHBwa4Og4iIirFr166hSpUqrg6jWOJxmIiIHgWPwXnHYzARET0KHoPzjsdgIiJ6FKX1GNyhQwe88cYbaNq0KUwmEz799FOcOHECp06dgpeXl1Pb4DGYiIgeRV6OwayUBcDHxwdAxi/Q19fXxdEQEVFxkpCQgODgYPlYQrnH4zAREeUFj8GPjsdgIiLKCx6DHx2PwURElBel/Ri8ceNGxe2FCxciMDAQhw4dQqtWrZzaBo/BRESUF49yDGZSFiCXp/T19eUBmIiI8oSljvOOx2EiInoUPAbnHY/BRET0KHgMzjseg4mI6FHwGJwhPj4eAFCuXDmn1+ExmIiIHkVejsFMyiIiIiIiIiIiIiIiIiIiomJBkiQMGTIELVu2RP369bOcZzAYYDAY5NsJCQmFER4REZFM7eoAiIiIiIiIiIiIiIiIiIiInBEREYETJ05g6dKl2c6LjIyEn5+ffAkODi6kCImIiDIwKYuIiIiIiIiIiIiIiIiIiIq8wYMHY926ddi+fTuqVKmS7dwxY8YgPj5evly7dq2QoiQiIsrApCwiIiLKM7PZjP/85z8IDQ2Fh4cHatSogYkTJ0II4erQiIiIiIiIiIiIiKiEEEJg8ODBWLNmDbZt24bQ0NAc19Hr9fD19VVciIiICpPW1QEQERFR8TVlyhTMnTsXixYtQr169XDw4EH0798ffn5++Oijj1wdHhERERERERERERGVABEREViyZAl+//13+Pj4ICYmBgDg5+cHDw8PF0dHRETkGJOyiIiIKM/27NmDV155BZ06dQIAVKtWDb/99hv++ecfF0dGRERERERERERERCXF3LlzAQBt2rRRjC9YsAD9+vUr/ICIiIicwPaFRERElGctWrTA1q1bce7cOQDA0aNHsXv3bnTs2NHFkRERERERERERERFRSSGEcHhhQhYRERVlrJRFREREeTZ69GgkJCSgdu3a0Gg0MJvNmDRpEnr16pXlOgaDAQaDQb6dkJBQGKESERERERERERERERERERUaVsoiIiKiPFu+fDkWL16MJUuW4N9//8WiRYvwzTffYNGiRVmuExkZCT8/P/kSHBxciBETERERERERERERERERERU8JmURERFRno0YMQKjR4/GG2+8gQYNGqB3794YOnQoIiMjs1xnzJgxiI+Ply/Xrl0rxIiJiIiIiIiIiIiIiIiIiAoe2xcSERFRnqWkpECtVuZ4azQaSJKU5Tp6vR56vb6gQyMiIiIiIiIiIiIiIiIichkmZREREVGevfTSS5g0aRKqVq2KevXq4fDhw/j2228xYMAAV4dGREREREREREREREREROQybF9IREREeTZz5kx069YNH3zwAerUqYNPPvkE7777LiZOnOjq0IiIiIiIiIhy7caNG3jrrbfg7+8PDw8PNGjQAAcPHpSXCyEwduxYVKxYER4eHmjXrh3Onz/vwoiJiIiIiIioqGKlLKIizCwJaNQqV4dRbAkhIASgLma/QyEE7qekw0OngYebBkIIpKabkZRmQpLBhAAfPXzcdRBC4EFKOoxmCeW83KDTZOTZppslaNUqqFQqeVt6rRpe+oyn/LR0M+ISDLidlAZ/Lz3K++hxP9kIo1mCJAlIIuN/z9dDi8plPBCTkIYUoxneei083TRIS5eQYjTBS6+Fj7sWeq1GjjstXYJaDWhUKmjUKggBxCUaYBYCFX3dHf4tTGYJMQlpSDaYodWoULmMB9w0aqSmm5FiNCPVaIaAQBkPN/i4a2E0S7h+PxWSEFCrALUq476W9dTBS6/FmVuJSDKY4KZVQ69VQ6dRw02rhlatQnxqOhLS0qFVq1HOS4cAb3f4emihUhWv/5GixMfHB9999x2+++47V4eC6DvJCPJzh7tO4+pQiIiIiIiIioy4xLSH74PdXB1KkXf//n20bNkSbdu2xZ9//omAgACcP38eZcuWled8/fXX+P7777Fo0SKEhobiP//5D8LDw3Hq1Cm4u7sXarzX7qXA39sNnm48zU9EROQq95KNMJklBPoW7usAIiIqHvhujSgX0tLNMJgkpKWbcel2Mu4mG2BIl6DTquGmUaFeJT8El/PE/WQjdFo1vPXZP8RO3IjH6VsJ6NakClSqjISRX/ddwcuNKuFcbCI+WPwvvPVaeLhpkGo0I8BHD61GBbMENA4ug0AfPYxmCYZ0CTEJqbiTaIRJkmCWBMxCQJIAL70GPu4ZySqGdDNSH96H8t5uCPL1gL93xgk5sySQbDDh6r0UqNUq+Hno4Ouue3ifzdCq1YhLTEO6WSDIzx16rRoalQomSeDGg1TEp6TDYJZgNEko46FDxTLuSDaY5KQhfy83pKZnJNj4Ptx2Ylo6zsUmwUuvgbdeCwFAiIfJVA+vSw8TqyQhkJhmQlq6GWU8dfD30kMSApfvJMPPUwcfdx3uJBogCQFPt4z7fCEuCanpZvh56KB2kHSj06hQ3luf8XtVq3D1XgpSjGaYJQGTJCHFaAYA+LrrYJYE0s0S0s0S3HUamCSBxLR0qKCSk5DU6oxEJM3DJCEg475IIiPRSRICEICHmwbSw2QpT50Gvh466LVqxCZk/H5VKsBgkgAAPu5apBrNMElCEbuXmwbpZgGjWZLHynrqIAkgPjUdAOCmzUjSMj7clpebBgKQ75czdBoV0s0i2zluWjV89FokppkU8djSPvz9AID1Fk1mCVL2u5CpVZD/NxzRqFUwO7uxh/4Y3BINq5TJ1TpU9Oy9eBc9f9yHxyt4Y/PQ1q4Oh4iIiIiIqEhIMZrw9KStAIBLk18sdl9cK2xTpkxBcHAwFixYII+FhobK14UQ+O677/D555/jlVdeAQD83//9HypUqIC1a9fijTfeKLRYz8QkoMN3u1DeW4+Dn7crtP0SERFRpvH/O4kFf0cDAE6MD8/xc0EiIip9eGSgUi/FaMK+S3fRsmZ5ueIPAPx+5AYW77+KWT2fQKCvOy7EJeGlmbuRmp51Qouvuxa7Rj6HJyZGAQCiv+qU7b7HrD6O4zfiUb+yH+pU9MW4P05izeEb+O/uy3ilcWUYTBIMJiOQnDH/brJRXvf0rYRHuNfF291kIy7eTlbczs69bJbfik/LcX+JaSbF7QTFbQE4n+OUsT2DSXHd+nZ2+1arAA+dBslGM5KtEqvUKkASwP2UdMW6lmQsC+t13HVqlPfWIy7RAKNJkqtKWRKn1CoV7qcYkW7OqNbmqdMgJT0jYU31MA5LcpfRJOGuKevfcUbVLiDdLOySyyzcNGr4uGuRlq68b0DGvgAgNd0sJ2/56LXQadWQhIBZykjcSzKYYJYE/Dx0CPDRw2jKSBJMf5gsaDRLGcmGHhlJdveSjYhPTUegD7+9UhKsOXwdAHAuNsnFkRARERERERUd1uc9zEJADSZlZeePP/5AeHg4unfvjp07d6Jy5cr44IMPMGjQIADA5cuXERMTg3btMpOg/Pz80KxZM+zdu7dQk7K2no4DANxJMhTaPomIiEjJkpAFAPW/2MQkeCIissOkLCr1fth5CTO2nsfEV+qhd1g1efzjpUcAAFM3ncXU7o1w9NoDOSFLrQKqlvNEoG9GmyyjyYx9l+4hIc2E0zGZyVKWZJesJKRlJNFYEm/2X7oLICPJKMWYMdahXhDeaV0dHjoNYhLSIIRAulng0JX7SH7Yos1Nq0YFH3dU8HWHVqOCVp1RtUmtUiHFYEJCWjoS00xw12ng6aaBVqPGnUQDYhPScDfZCLUK0KjVcNepEVzWEypVRrWlhFQTPNzU0Gs1SDdLKO+th06jRkxCGkxmCWYhoIIKlcq4w99Ln9EqTqvG7Yfb9vXQoYyHDjqNGneTDfB008BDp0FCmgkJqenQadSoW8kXqUYzUowmqFQZMasAqNWAChnJPKqHY97uWnjoNLifYsS9ZCPMkkD18t5ISEtHksGEQB89tGo1Eg3piE9JR2iAF8p6uuFBSnpGlSobRpOEu8kGxCUYYDBJqOrvCV93nZyY5OGmkf8+WrUKOo0aGjWQli5Bq1HBx10HAJAkIVcnE0LALEFOXlKrVNCoId83AEg2mKBSAeW83JBqNCMhzYRUoxkVfPXQ6zSQJIFAXz1SjWbcSTLC+2GbQE83TUZFtZR03EsxypW+3DRq3E8x4k6SESoVEOCdUUXMYMqomhboq4fBJOFuUsbfuoynG3zdM1r2maWM1oheD7dt+/uJiU9DBT899NqMNooGU0ZrRK1GDbMkkGQwIfHh/5ePuxZlPN0yKoM9/J1IIqOCFwDcTjI4rIilU2fcD7U6o92iJYnOw00Dd61GfgNjMJkRn5oOjUqFcl5udvGmGE24l2xEJT8Pp9/0pKWb4abJ+jFKxYeKHywQERERERHRI7p06RLmzp2LYcOG4dNPP8WBAwfw0Ucfwc3NDX379kVMTAwAoEKFCor1KlSoIC9zxGAwwGDITJ5KSHj0L1tKuawUTkRERAVv9eEb6NakiqvDICKiIoRJWVTqWb5NdjvJcaWf5IfJUZYkqXZ1KmBOrycVyVZCCISO2QAgoyqQRarRnG1SliVRyPLTkgSUsb+MBLCmoeXwZNWyAIA6FX3l5eH1gpy5ewSgQjHt463XalDG081u3M9TB7+HiU4W/t56+Hvrs92Wr7vOblyjVmVZTtdNq0ZVf0/5tkqlgrsu839U87DNpZ+H/XYdqejnkeMclUqV5f3QazUI9NE4XAYAnm5aeLrl7rBmfX+oeHPQoZSIiIiIiIgoVyRJwlNPPYXJkycDAJ544gmcOHEC8+bNQ9++ffO83cjISIwfPz6/wgQANK5aBgCg0/ANMRERUVHxyYqjTMoiIiIFlgehUs/ynTLhoJISALmloaWlWhlPnV2ilUqVUVkJgKISkCWhKyuSZNl3xk/rBBFLEpinG5NGiIhyYls5jYiIiIiIiCi3KlasiLp16yrG6tSpg6tXrwIAgoIyviQZGxurmBMbGysvc2TMmDGIj4+XL9euXXvkWD0enkesUtYzh5lERERUEJINjj8DrDZ6fSFHQkRERRmTsqjUEzbVqmzpHyZgpTx8ceWVRZKUxqrFmoWl2lVWLPu0xOChs6+UxaQsIqKcMSeLiIiIiIiIHlXLli1x9uxZxdi5c+cQEhICAAgNDUVQUBC2bt0qL09ISMD+/fsRFhaW5Xb1ej18fX0VFyIiIire9ly8m+Wyf6/eL8RIiIioKGNSFpV6llwsyXFOlpyUZamU5ZlFqzdL20KjSZLHUnKqlCUnhGXctm5faNmfVy7bsRERlUbMySIiIiIiIqJHNXToUOzbtw+TJ0/GhQsXsGTJEsyfPx8REREAMqo0DxkyBF9++SX++OMPHD9+HH369EGlSpXQpUsXl8ScVfV/IiIiKljZnZN+bc4emMxSNjOIiKi0YFIWlXpSTpWyHlavsiRYZVkpS2WflJVsyKlSVsZP8bCJonX7wlS2LyQichorZREREREREdGjatq0KdasWYPffvsN9evXx8SJE/Hdd9+hV69e8pyRI0fiww8/xDvvvIOmTZsiKSkJGzduhLu7e6HGyvfBRERERdvXm87mPImIiEo8luChUs+Si2Wdk2WdWCVXyjJY2gk6fthoNJb2hZnrpqbnUClLsqmUZZWUJe8vi8pcRESUScVaWURERERERJQPOnfujM6dO2e5XKVSYcKECZgwYUIhRpU11skiIiJyjf2Xs25fCADz/7qET1+sU0jREBFRUcVKWVTqWRKiJKv+hanGzApXbpqMh4lcKUvvuHKVpX2hwZS5bs6VspRVutx1mQ/JZFbKIiJyGr8hTERERERERKUL3wgTERG50o+7Litu//ufF+zmPPVlFK7dSymskIiIqAhiUhaVepbWgVY5WXJCFJD5QX+OlbLU9pWyUow5VMqy7NNBpaz41PSH+2NSFhFRTtTMyiIiIiIiIiIiIiIiF2hftwLKebmhXiVfxfidJCOe/Xq7i6IiIqKigElZVOpZ2hZKVv0LU6wqZZkeZk7lVClL8zAhwKhIysqhUpakrJSlt0rKsoTjlUUSGBEREREREREREZVugv0LiYiIXG7GG08AAH6PaOlwuXWXHSIiKl2YlEWlnnh45kIokrIyK1yZHyZOJRtzqJSlcVQpy7n2hdmdPPFgpSwiohyxUBYRERERERGVJnwfTEREVHRYPsvTatSY2KW+3fJan28s7JCIiKiIYFIWlXqSUP4EMlsVAlaVsgwPK2VlkZSlVWc8nKyTspINzrUvtCRnSZIyO0ujVkGv5cOUiCgnKvBsNBERFQ1z585Fw4YN4evrC19fX4SFheHPP/+Ul6elpSEiIgL+/v7w9vZG165dERsbq9jG1atX0alTJ3h6eiIwMBAjRoyAyaR8b7Fjxw48+eST0Ov1qFmzJhYuXFgYd4+IiIiIiIiIstG7eYjD8a83ninkSIiIqChgtgeVepY0KOv2hanp2VTKyqp9odpSKSszoSunSllmSzKWg8QwAPDUaaDi196IiHLEp0oiIioqqlSpgq+++gqHDh3CwYMH8dxzz+GVV17ByZMnAQBDhw7F//73P6xYsQI7d+7EzZs38dprr8nrm81mdOrUCUajEXv27MGiRYuwcOFCjB07Vp5z+fJldOrUCW3btsWRI0cwZMgQvP3229i0aVOh318iIiJyLQH2LyQiIipqxr1U125szo6LLoiEiIhczWVJWdHR0Rg4cCBCQ0Ph4eGBGjVq4IsvvoDRaFTMO3bsGJ599lm4u7sjODgYX3/9td22VqxYgdq1a8Pd3R0NGjTAhg0bCutuUAkg2SRGATaVsswPK2UZc6qUlZERYFS0L8y+UlZmy0RLDMqTKFklgBERkZKaSVlERFREvPTSS3jxxRfx2GOP4fHHH8ekSZPg7e2Nffv2IT4+Hj///DO+/fZbPPfcc2jSpAkWLFiAPXv2YN++fQCAzZs349SpU/j111/RuHFjdOzYERMnTsTs2bPl98vz5s1DaGgopk2bhjp16mDw4MHo1q0bpk+f7sq7TkRERIWIb4OJiIiKrn4tQx2Om8ySw3EiIiq5XJaUdebMGUiShB9++AEnT57E9OnTMW/ePHz66afynISEBLRv3x4hISE4dOgQpk6dinHjxmH+/PnynD179qBnz54YOHAgDh8+jC5duqBLly44ceKEK+4WFUcP86CEVUKUdTKVWZJgNElIf5iclVWilFpln5SVnEOlLNsKWcI2KSuLBDAiIlJiVUEiIiqKzGYzli5diuTkZISFheHQoUNIT09Hu3bt5Dm1a9dG1apVsXfvXgDA3r170aBBA1SoUEGeEx4ejoSEBLna1t69exXbsMyxbIOIiIiIiIiIXGvLsFZ2YzU/+9MFkRARkSu5LOOjQ4cO6NChg3y7evXqOHv2LObOnYtvvvkGALB48WIYjUb897//hZubG+rVq4cjR47g22+/xTvvvAMAmDFjBjp06IARI0YAACZOnIioqCjMmjUL8+bNK/w7RsVOZqWszIQoRaUsSSiStDx1jpOytBpL+0KrSlmG7CtlWVojWnZtW2zc042VsoiInMGULCIiKkqOHz+OsLAwpKWlwdvbG2vWrEHdunVx5MgRuLm5oUyZMor5FSpUQExMDAAgJiZGkZBlWW5Zlt2chIQEpKamwsPDw2FcBoMBBoNBvp2QkPBI95OIiIhcT7B7IRERUZFUM9DH4fiyA1fxetOqhRwNERG5issqZTkSHx+PcuXKybf37t2LVq1awc3NTR4LDw/H2bNncf/+fXkOvyFMj0LYVKsCgNT0zKQssyTkild6rRpajeOHjUbtICkrm0pZ1lWxHCWGAVm3SiQiIhvMyiIioiKkVq1aOHLkCPbv34/3338fffv2xalTp1wdFiIjI+Hn5ydfgoODXR0SERER5RErRhMRERV96z58xm5s1KrjmLPjgguiISIiVygySVkXLlzAzJkz8e6778pjj/INYctyRwwGAxISEhQXKr0cV8rKrHBlkoR820ufdZKUVm1pX5iZiJVdUpZ1ElhmDMo5HqyURUTkFBWzsoiIqAhxc3NDzZo10aRJE0RGRqJRo0aYMWMGgoKCYDQa8eDBA8X82NhYBAUFAQCCgoIQGxtrt9yyLLs5vr6+WVbJAoAxY8YgPj5evly7du1R7yoRERG5GCtlERERFV31Kvk6HP9649lCjoSIiFwl35OyRo8eDZVKle3lzJkzinVu3LiBDh06oHv37hg0aFB+h2SH3w4ma5bzFtYnMKyTqSSrpKzs2gmqVZakrMxKWcnGrNsXmm0zsKCsngUAXnomZREROUPNnCwiIirCJEmCwWBAkyZNoNPpsHXrVnnZ2bNncfXqVYSFhQEAwsLCcPz4ccTFxclzoqKi4Ovri7p168pzrLdhmWPZRlb0ej18fX0VFyIiIiqe+DaYiIio6FOpVLgwqaPDZbafCRIRUcmU773Rhg8fjn79+mU7p3r16vL1mzdvom3btmjRogXmz5+vmPco3xC2LHdkzJgxGDZsmHw7ISGBiVmlmHBQKSvFqKyUZUnSyq6doFZj374wNdtKWQ7aF0rKOR46ti8kInIGuzYQEVFRMWbMGHTs2BFVq1ZFYmIilixZgh07dmDTpk3w8/PDwIEDMWzYMJQrVw6+vr748MMPERYWhubNmwMA2rdvj7p166J37974+uuvERMTg88//xwRERHQ6/UAgPfeew+zZs3CyJEjMWDAAGzbtg3Lly/H+vXrXXnXiYiIiIiIiMiGVqPGY4HeOB+XpBgPHbMBFye/CA2/cUxEVKLle8ZHQEAAAgICnJp748YNtG3bFk2aNMGCBQugVisLd4WFheGzzz5Deno6dDodgIxv/9aqVQtly5aV52zduhVDhgyR18vpG8J6vV4+mU1kyY2yLlyVbJVMZbaulJVN5SrNw/9f66Qs6zaIWe1XGQMrZRER5QXbFxIRUVERFxeHPn364NatW/Dz80PDhg2xadMmvPDCCwCA6dOnQ61Wo2vXrjAYDAgPD8ecOXPk9TUaDdatW4f3338fYWFh8PLyQt++fTFhwgR5TmhoKNavX4+hQ4dixowZqFKlCn766SeEh4cX+v0lIiIiIiIiouxFDWuNaqPtv0jVdNIW/PufF1wQERERFRaXleG5ceMG2rRpg5CQEHzzzTe4ffu2vMxS5erNN9/E+PHjMXDgQIwaNQonTpzAjBkzMH36dHnuxx9/jNatW2PatGno1KkTli5dioMHD9pV3SLKiiUNSlEpy2BdKUtyrlKW2lIpKzOhK8VohhACKgclXJSVspQ/LTyz2R8REWVipSwiIioqfv7552yXu7u7Y/bs2Zg9e3aWc0JCQrBhw4Zst9OmTRscPnw4TzESERFR8cf3wURERMXfvWQj1hy+ji6NKzv8LJGIiIo/dc5TCkZUVBQuXLiArVu3okqVKqhYsaJ8sfDz88PmzZtx+fJlNGnSBMOHD8fYsWPxzjvvyHNatGiBJUuWYP78+WjUqBFWrlyJtWvXon79+q64W1QMWZKjrHs321XKetjO0NMtu0pZGS+WjFaVskySgNEsOZxvdtC+0LZ/dHb7IyKiTHy7SkRERERERERERERF1ZmJHRyOD112FFtPxxVyNEREVFhcVoanX79+6NevX47zGjZsiF27dmU7p3v37ujevXs+RUaljdw60Cp3KtUqKcskCaQYHlbK0mf9kNGo7JOyLNvSa+2Tq4T1tCzaFzIpi4jISfwWERERERERucD8vy4i3SwQ0bamq0OhUsr2S55ERERUOFrU8Meei3fh7+Xm1Hx3Xdaf+b39fwcR/VWn/AqNiIiKEJdVyiIqKiyJUJKiUlZm+0KnK2VpLO0LlUlZ1lW3HO1XGYNyDtsXEhEREREREREVTSlGEyZvOIOpm87iTpLB1eFQKaNizWgiIiKX2nPxLgDgbrLR6XWOjH0hy2UHou89ckxERFT0MCmL6CHrhChLZSwAMJkFUow5V8rSqh0nZaUYTI6m27QvtPxUZmV56Vkpi4iIiIiIiIioKDJZnUyyrZxOVFhYJ4uIiKj4KOPphsP/cZyY1X3eXsSnphdyREREVNCYlEWlniURyrrUd4ptpSyDE5Wy1I7bF6Y4USlLwBKDcg4rZREREREREREREZEtFQtlERERFUtls2l32Gj8ZrYmJiIqYZiURaWesKlSJYRQJFKZJCmzUlY2SVIaleOkLOtWiI72m7FvZQwW2SWBEREREREREREREREREVHxMuGVelkuW/3vjUKMhIiIChqTsqjUsyRCWRKjjGZJUX5eUSkrm3aCWo1KXt+adStEa2brfolyDEzKIiIiIiIiIiIiIuewmAYREVHx0yesWpbLhq84im1nYiFJPMgTEZUETMqiUs+2UlaqTbtBkyScq5SldlwzPCU95/aFltdVbF9IRJQ37NpARERERERERERERMXFLwOfznLZgIUH8fGyI4UXDBERFRgmZVGpJ2wSopJtkrLMkpBbEGZXuUqrdvxwWnf0JuIS0rLcL2BfrcuClbKIiIiIiIiIiIiIiIiISpZnHwvIdvn/jt7EkWsPCicYIiIqMEzKolJPQNk6MOVhq0ILsySQlp7RktBdl3WSVFaVsjafikW/BQfsxq3bF2YmhmWO6bVqlPNyc+IeEBERERERERERUWlkObdJRERExc/5SR2zXd5l9t+FFAkRERUUJmVRqSfZtC+0JGBZmCWBdHPGmJs264eMbVJWg8p+8vUbD1Id7FfYXbf8fKdVdax4LwxeerYvJCIiIiIiIiIiIiWV4++HEhERUTEinMitvnI3ueADISKiAsOkLCr1hE3rQMnmFZDJKilLp8n6bIdtUla7OhWw/ZM2AJRVsSwcDMljtSr4oGGVMk5ET0RERERERERERKWVMx/mEhERUdHkTMXL1lN3IMVoynEeEREVTUzKolJPsmkdaLY5k2GWBNJNlqSsrB8yWpukLK1GJY85TsrKulKWmo9MIiIiIiIiIiKHZm49jwELD8BklnKeXMqxmFLJpeJfl4iIqNjTazXoGxaClxtVynZe3bGbCikiIiLKb0z9oFLPkholV8qSbCtlSTCaM8ayS8qyrZSlUavksZyTsh7G8vCnmvXHiYiIiIiIiIgcmhZ1DtvOxCHqVKyrQyEiIiIieiTjX6mP73s+keO8aqPXIzYhrRAiIiKi/MSkLCr1hE2VKtv8KbOifWE2SVk2iVRadWalLJNk/81N6yFh0zpRxaQsIqJc4dMmEREREVHpYzCxUpatLadiMXXTGbsvHVLJxb80ERFRydClcfbVsgCg2eSt2HE2Dr/uu8KqsURExYTW1QEQuVpmQlTGT0tVK5UqY5nJKinLLbukLE3WlbIkkVGBS21VTSvb9oVMLiAiIiIiIiIiolx6+/8OAgDqVfLDiw0qKpYJZu+UKPxyEhERUcny3RtP4KuuDVH7PxuznddvwQEAgNEkYcAzoYURGhERPQJWyqJSz5IIJWx+WhKwzGarSlnarM92aB20L9SqMx9iZpszX5KDM2ES2xcSEREREREREdEjiolnaxsiIiKi4sZdp8Gxce2dmjth3akCjoaIiPIDk7Ko1LNtHWi2ScpKlySkmzPGsm1fqFbb3FbBesgs2SZlWV2XlAlhrJRFREREREREREREOWEFNCIiopLF113n9FzBFwJEREUek7Ko1LO8XJEetl62JE/ptBkPD4MpsyezTp31Q8a2UpbWtlKWXVKWdftC5U8VK2URERERERERERFRFnj6kIiIqOQ692VHp+aFjtmA8f87KRd/ICKioodJWVTqWbLIM9sYZozrNCrFbSD79oVqu/aFamisxky2SVlWtwWUMfCcChEREREREREREREREVHp46ZV49LkF9GtSZUc5y74OxrVP92Aw1fvAwAS09ILOjwiIsoFrasDIHI1S9KV5aelopWb1j5nMbv2hbaVsjRq5Vi27QttYlDzq25ERERERERERESUI1bGICIiKmy2n/kVBLVahW+6N8LKQ9edmv/qnD3y9UUDnkbrxwMKKjQiIsoFVsqiUk+yqZRl+enmIAHLNvHKmsZBpSy1WiWXEjdJkmK5dftCIVfpyviZTZdEIiJyQMUag0RERERERFSK8H0wERGR66w7dlO+XtZT58JIHOv7339cHQIRET3E1A8q9SypUbZJWbZVsdw0aqiyqWBlm7BluW35aVcpy7p9obDEkPEzu/0QERERERERERERAZnnFYmIiKjwnL6VKF8v6+lWoPvaOrw1fNxz3/yq2uj1iFjybwFEREREucGkLCr1JLlKVcZt88OCVnqb9oU6TfaJUvaVslSKnyZzdu0LlQlhbF9IRMXJjRs38NZbb8Hf3x8eHh5o0KABDh486OqwiIiIiIjICZIkcPpWQqG0YCGi/MPTh0RERK7jodNk3ijgY3KNAG8cHxeOnk9XzfW664/dQrXR6/H0pC1IN0s5r0BERPmOSVlEcpUqm/aFNklZWgftDK3ZJWU9PDNi+WlXKcu6faE8lvEzmy6JRERFyv3799GyZUvodDr8+eefOHXqFKZNm4ayZcu6OjQiIiIiInLCt1Hn0HHGLvzn9xOuDoWIiIiIqFjQWhVy+LxTnULZ5xcv1cUHbWrkad24RAO+33o+nyMiIiJnMCmLSr3MZCzlbdv2hba3bdm2L9RolJWyzDa1xK1vZ1brYqUsIipepkyZguDgYCxYsABPP/00QkND0b59e9Sokbc3h0REREREVLhmbb8AAFiy/6qLIyGivGCNOyIiItfy8yjY9oUW7joNRnaojTMTO6B385Bcrz9z2wU8M2Ubjl1/kP/BERFRlpiURaVeZpWqjGuWilYatUpRscotx/aFNpW1Hq5sqbBlWylLWFfKskkIY04WERUXf/zxB5566il0794dgYGBeOKJJ/Djjz9mu47BYEBCQoLiQkRERERERETO4+lDIiKiosG2k05Bc9dpMLFLfVyc/GKu171+PxUvz/obL3y7ExLblxMRFQomZVGpl1mlynI746dapYLWKtFKp81lpSy1slKWyWzTvtCqdbOwqdbFSllEVFxcunQJc+fOxWOPPYZNmzbh/fffx0cffYRFixZluU5kZCT8/PzkS3Bw8CPHwadNIiIiIiIiIiIiIioM6ebMD/nqV/J1SQwatQrHxrXP07rn45JQ/dMNOBuTiMkbTqP55K2IvpOczxESERHApCwiuypVklWlLOvs9pzaF6ptkrIsCV2WZC3bSlnK9oXKGJiURUTFhSRJePLJJzF58mQ88cQTeOeddzBo0CDMmzcvy3XGjBmD+Ph4+XLt2rVCjJiIiIiIiIio5LCuxk9ERESF48ytRPm6NofPDwuSr7sOlyNfxLy3muRp/fDv/sL8vy4hJiENbb7ZgfjU9HyOkIiImJRFpZ5dUpZVYpQ2F0lZ9pWyLD8fVsqyLo0Fx+0LhVwpy/n4iYhcqWLFiqhbt65irE6dOrh69WqW6+j1evj6+iouRERERERUuu25cAe/7I12dRhExQa/00lEROQ6AkUnKVqlUqFD/SBM7FL/kbf141+XkJZuRnwKk7OIiPKL1tUBELmabetAs5yUBWg01klZ2Z/psO0ZrXlYKUuTRaUs65u2CWEqnlUhomKiZcuWOHv2rGLs3LlzCAkJcVFERERERERUHL35034AQK0gXzwdWs7F0RAVH0XnI2EiIqLSQyqCB+DezUPQu3kIbsWnotvcvbjxIDXX25i1/QJmbb8AADg6tj38PHX5HSYRUanDSllU6klylSr79oWPUinLcjvrpCzrSlm2VbpydReIiFxm6NCh2LdvHyZPnowLFy5gyZIlmD9/PiIiIlwdGhERERERFUPX76e4OgSiYoInEImIiFwl3SzlPMlFKvp54O/Rz2FK1waPtJ1GEzaj2uj1iIlPy6fIiIhKJyZlUalnKTEqyW0MM36qVSpF9aucKmWp7SplZdzWZpGUZX3bcs3S4ZCVsoiouGjatCnWrFmD3377DfXr18fEiRPx3XffoVevXq4OjYiIiIiIiChXxo0bB5VKpbjUrl1bXp6WloaIiAj4+/vD29sbXbt2RWxsrAsjJiIiIlfYcfa2q0PIUY+ngrFpSCusjWj5SNtpHrkV1Uavx/ID1zB7+wXcSTLkU4RERKUD2xdSqZeZjJVxxZIspVaroFVn5i3mtlKWRq6UlbGeySYpSzhoXyhYKYuIiqHOnTujc+fOLo3hXrJRvp5ulnJ8ziYiIiIiIiJypF69etiyZYt8W6vNPIU+dOhQrF+/HitWrICfnx8GDx6M1157DX///bcrQgWgPMdIREREZKFSqVAryAcAcDnyRaSmm1F37KY8b2/kqmMAgKmbzuLS5BftilUQEZFjTMqiUs9y4sLSttCSIKVRQVEpyy2HD/g1uayUpWxf+PDnw9tqVsoiIsqVJINJvi7xjDQRERERERHlkVarRVBQkN14fHw8fv75ZyxZsgTPPfccAGDBggWoU6cO9u3bh+bNmxdqnDx9SERERM5SqVTwdNPicuSLSDKYcOVuCjrP3J3n7VX/dAMAYMYbjdG0WjkE+Oj5RWkioizw2ZFKPSFXqcq4LcnVqlSK6lc5V8pS29y2VMrK+GlbKcs6Scu2WhdPqhARERERERERERW+8+fPo1KlSqhevTp69eqFq1evAgAOHTqE9PR0tGvXTp5bu3ZtVK1aFXv37nVVuEREREROU6lU8HHXoX5lP0R/1QmTX23wSNv7eOkRtPhqGx777E88SDEiLiENey/exV/nin57RyKiwsJKWVTqWVKjMtsXZtxWq1WK0ps67aNWypKU+xXW1y1Vuh7um1lZRERERERERESlXlxiGoYsPYI3m1VF54aVXB1OidesWTMsXLgQtWrVwq1btzB+/Hg8++yzOHHiBGJiYuDm5oYyZcoo1qlQoQJiYmKy3a7BYIDBYJBvJyQk5FvMgtWiiYiIKI/ebFYVDav4YcbW89h2Js6u609uNJ4Qpbg9s+cTeKlRJQghYDRL0Gs1jxouEVGxxKQsKvVsE6IyK2VBWSkrh97ItklZlspZajkpSznfYftCqypdRERERERERERUuk1efxp7Lt7Fnot3mZRVCDp27Chfb9iwIZo1a4aQkBAsX74cHh4eed5uZGQkxo8fnx8hynj2kIiIiPJD/cp++LHPUwCAZIMJL8/ajYu3kx95ux/+dhgf/nZYvr3q/Rao6OeO+X9dwtAXHoefh+6R90FEVBwwKYtKPdtkLOnhgEatUiRa5dy+UHkqxNLNUCu3L1RmZZmFdftC20pZubgDRERERERERFRqmCVh98UwKrnup6S7OoRSrUyZMnj88cdx4cIFvPDCCzAajXjw4IGiWlZsbCyCgoKy3c6YMWMwbNgw+XZCQgKCg4MLKmwiIiKiPPHSa7F5aGuoAIxadQzbz95GullCfOqjvybtOnePfH3hnmgAwNjOddGsejmcj03Cy40qKToYERGVFEzKolLPUp1KyMlZGT/VKpWyUpY2b5WyNHKlLGXJT+ubti0UVayURUSUZ+zcQEREREQl1b5Ld9Hnv//gi5fqolezEFeHQ1TiJSUl4eLFi+jduzeaNGkCnU6HrVu3omvXrgCAs2fP4urVqwgLC8t2O3q9Hnq9vkBi5FtgIiIiyk+WzzWndm8EIYT8meXF20l4/9dDOBeblG/7mrDulHx9yLIj0GlUmPhKfSQbzUg2mFC1nCda1PBHgI+en50SUbHFpCwq9YRNpSyzVQvBR6mUZVk3s1KW8hSJcFQpS8psnUhERM7j0yYRERERlQaDl/wLo0nCZ2tOMCmLqAB88skneOmllxASEoKbN2/iiy++gEajQc+ePeHn54eBAwdi2LBhKFeuHHx9ffHhhx8iLCwMzZs3L/RY+cEkERERFTTr1xs1AryxeWhrAEBiWjoajNuc7/tLNwuMXn3c4bK3mldFvxahOHTlHvw8dEhINaFjgyD4uLMNIhEVbdlnmRQSg8GAxo0bQ6VS4ciRI4plx44dw7PPPgt3d3cEBwfj66+/tlt/xYoVqF27Ntzd3dGgQQNs2LChkCKnksC2SpV1+0JLtSsAcMshKcu2pKYlGUvzcBu2lbKsb1vys4RVlS4iInIenzaJiIiIiIjoUV2/fh09e/ZErVq10KNHD/j7+2Pfvn0ICAgAAEyfPh2dO3dG165d0apVKwQFBWH16tWuDZqlsoiIiKiQ+bjr8L/Bz2DJoGa4OPlFvNyoUoHv89d9V9Hu250Yteo43vv1X4xcdQwNxm1GtdHrEbnhNA5E34PRJAEA0tLNuHwnucBjIiJyRpGolDVy5EhUqlQJR48eVYwnJCSgffv2aNeuHebNm4fjx49jwIABKFOmDN555x0AwJ49e9CzZ09ERkaic+fOWLJkCbp06YJ///0X9evXd8XdoWJGTsayqZhV0JWyFO0L5Rgy901ERERERERERFkr6qdP0tLN6PPzP2j1eHkMfu4xV4dDTli6dGm2y93d3TF79mzMnj27kCLKWhH/9yciIiows2fPxtSpUxETE4NGjRph5syZePrpp10dVqnToIqffP37nk/g+55PoNnkLXiqWjl8060RTt6MR/+FB5CYZirwWH746xJ++OtStnNGdqgFH3cdQv294Oehw+NB3tCq1Ug2muDrroPRJOF8XCLqVvTNsiKpWRKKz46JiJzh8qSsP//8E5s3b8aqVavw559/KpYtXrwYRqMR//3vf+Hm5oZ69erhyJEj+Pbbb+WkrBkzZqBDhw4YMWIEAGDixImIiorCrFmzMG/evEK/P1T8CJvkqMz2hYBWk3lgtb7uiO1B2HJb83A9s1my2a91+0Llz6J+UpGIiIiIiIiIiLK34tB1/BN9D/9E32NSFhEREVE+WLZsGYYNG4Z58+ahWbNm+O677xAeHo6zZ88iMDDQ1eGVevs/bSdff6paORwfFw4AWHnoOj5ZcTSr1QrF1xvP5mp+OS83bBrSCk0nbVGMPxbojUbBZfBOq+oI8nPH4asPUKuCD9LNErz0WtxLNqJmoDcS0tLhqdMg2WiGEAImSaC8t95uP5Ik7LoxOSKEkJPFrK/nN6NJgiQE3HWaPG+jIOJLNphwKz4NNQO983W7RIXBpUlZsbGxGDRoENauXQtPT0+75Xv37kWrVq3g5uYmj4WHh2PKlCm4f/8+ypYti71792LYsGGK9cLDw7F27dqCDp9KCMkmOcq6fWHuKmUpl2seHmwsP802pcSt2xdKtpWymGVNRERERERERFSsGdLNrg6BSgF2LyQiotLk22+/xaBBg9C/f38AwLx587B+/Xr897//xejRo10cHWWlW5Mq6NakCoQQ2HwqFnUr+iK4nCeEEJiz4yL0WjW+XH/a1WEq3Es22iVkAcD5uCScj0vCykPXXRBVyVC/si9i4tNQt5IftGoV9l26ixSj8++dynjq8HigDw5euQfpEV8Mh5b3KpBWl+3qVMCW07F2421rBWD72dv4bVBzrP73OlYcuo7ODSti3bFbBRZPuzqB+OfyPdQI9Mbhqw+woH9TjF51DLEJBgDAq09URpOQsvh87Ql5nbeaV8WS/Vcd/n6ndW+Eo9cf4P/2XnFq/zN7PoEPfzsMAFgb0RJDlx3J8j42CSmLsp46bDkdJ4993qkOYhPS8OOuy6gd5IMzMYlw06hhNEuY/GoDpBhNuH4/FTUCveGp0+DkzQRUKuOOC3FJCPDRo8dTwahS1qPAEhmd4bKkLCEE+vXrh/feew9PPfUUoqOj7ebExMQgNDRUMVahQgV5WdmyZRETEyOPWc+JiYnJct8GgwEGg0G+nZCQ8Aj3hIo76+cSSQiralUqRUtCtxySsqwTuNSqzMQqyzbMkrJSlqJ9oeWnyFyfiIiIiIiKn8jISKxevRpnzpyBh4cHWrRogSlTpqBWrVrynDZt2mDnzp2K9d59911FteerV6/i/fffx/bt2+Ht7Y2+ffsiMjISWm3m2/gdO3Zg2LBhOHnyJIKDg/H555+jX79+BX4fiYiIyPVYaZ+IiEobo9GIQ4cOYcyYMfKYWq1Gu3btsHfvXofr8DPhokWlUiG8XpDidkTbmgCAt5+tLo+fuBGPKRvPoPtTwfh281mkppsx4ZX6ePeXQ4UeM+W/EzcyHod/nbudp/UfpKTjn+h7+RJLQSRkAXCYkAUA289m3OeeP+6TxywJWQUVjyXB6fDVBwCA/gsOKJavOXwDaw7fUIz9uu9qltsbnsuqd5aELADoMvvvbOceunLfbsw6YfNMTCIAwPiwQ9mna47nuP+Z2y4AAP7b7yk8V7tCDrMLRr4nZY0ePRpTpkzJds7p06exefNmJCYmKg6chSUyMhLjx48v9P1S0aRsIyjkClYaNWwqZTnfvtC6apZl3GSTSmpdoUvYVMpSgWdViIhyg8+bRERUVOzcuRMRERFo2rQpTCYTPv30U7Rv3x6nTp2Cl5eXPG/QoEGYMGGCfNu6erTZbEanTp0QFBSEPXv24NatW+jTpw90Oh0mT54MALh8+TI6deqE9957D4sXL8bWrVvx9ttvo2LFiggPDy+8O0xERERERERUCO7cuQOz2eywWMeZM2ccrsPPhIun+pX98MvAZgCAlxtVksejv+oEo0mCSpXRqUitViExLR1X7qbAYJIwcuVReLvrcPTaAxdFTkRF1cYTMSUnKWv48OE5fjO3evXq2LZtG/bu3Qu9Xtk79amnnkKvXr2waNEiBAUFITZWmUVouR0UFCT/dDTHstyRMWPGKFoeJiQkIDg4OMf7RiWTEMrrlgQpjUqlSK7SabOvlGVd3cq6k6H2YTKX2aZ/oVAkZWX8lNsXMreAiChX+A1hIiIqKjZu3Ki4vXDhQgQGBuLQoUNo1aqVPO7p6Znl+9bNmzfj1KlT2LJlCypUqIDGjRtj4sSJGDVqFMaNGwc3NzfMmzcPoaGhmDZtGgCgTp062L17N6ZPn86kLCIikrmyRQMVDutzjERERKTEz4RLHjebz2t93HWoX9kPALB1eBsAQGJaOjadjMULdSrAz1OnmB+bkIZAHz3uJhux9+JdaNUqtK0diHF/nMTSA9fg56FDfGp6xrb1WiQaTAV/p4iowI1/ub7L9p3vSVkBAQEICAjIcd7333+PL7/8Ur598+ZNhIeHY9myZWjWLCPzNSwsDJ999hnS09Oh02U8YUZFRaFWrVooW7asPGfr1q0YMmSIvK2oqCiEhYVluW+9Xm+XDEall2RbKctSrUqlsqmUlX1SlqXdoUkSTlXKMlt1M7TEYJnBE2ZERERERCVDfHw8AKBcuXKK8cWLF+PXX39FUFAQXnrpJfznP/+Rq2Xt3bsXDRo0UHz7Nzw8HO+//z5OnjyJJ554Anv37kW7du0U2wwPD1e8N7bFtg1ERAWHaTFU2FgxmoiISpvy5ctDo9HkqlgHPxMunXzcdejWpIrDZRV83QEA5b31eMmqCtdXXRviq64NAQBmScif724+GYO5Oy/ixz5Pobx31v9LQgjEJhhwJ8mAepV8IYmMIhyWz3wlyfL5Mx7+zLgSn5oOPw+dvM8UowmebpkpHKlGM9x1aqhUKvz41yVcuZeML7s0gCQJGM0S3HUaJKaly+sIIXA/JR0BPnr59v7L9/DXudtoUNkPl+8mY8eZ21g04GncSTIguJwnDl25jztJBrSvWwHX7qXiTEwC2lu1mTSaJCQZTFiy/wq6NQlGeW83aK0+N49PTYePXguVKqMa0eQ/T2P1+y3lGCxxCAEkGkzQaVRw12rk34cQgFqtghBC8Rm5EAJbTsfh6WrlcPluMrrM/hsr3gtDaHkvlPfWI8VogiQALzcNJKHsamUhSQJqtQpmSeCfy/fQvHo5eR8ms4RP1xxHvxahqFvJ1+Hf1WiSMGb1cYT4e8LTTYMBLUOhzqa6ihACJknkmFfgyMXbSbh6NwVtawfK27J0+NLmYXsAkG6W5KpyjmK1/j/00WsV824nGlDe2w0qVcbvTwgBrUaNFKMJZ2ISUa+SL/QP/44WRpMEnUaV61wHyxdNbsWnoaKfO+4kGe3+f2y3eSfJgFsP0lCnog8S0kwo5+UGIQRiEtLg56GDXquRC+G4Ovci35OynFW1alXFbW9vbwBAjRo1UKVKxpPkm2++ifHjx2PgwIEYNWoUTpw4gRkzZmD69Onyeh9//DFat26NadOmoVOnTli6dCkOHjyI+fPnF96doWLN+qSZJDKTpTTqjCQrCzcnnuw0D5OyHLUyNGfTvlASmQcjgJWyiIiIiIhKAkmSMGTIELRs2RL162d+G+vNN99ESEgIKlWqhGPHjmHUqFE4e/YsVq9eDQCIiYlx2I7Bsiy7OQkJCUhNTYWHh4ddPGzbQFT8sSBO0cLTN1QU8GmBiIhKCzc3NzRp0gRbt25Fly5dAGS87966dSsGDx7s2uCoRLH+nLd9vSBFglJWVCoVgvzcEeSXkfSlsXmzkFUij5+HTrFP64QsAPBwy0x6GdSqumJ77uqMZT7u1tXAVIpkFpVKhebV/dG8ur889kGbmgCA4HIZXw5sElJWXlbV3xNV/T0VMbhp1SindcPg5x7L9j4AQMcGFdGxQUW7OSqVCiqVcm7mssw5tuu8UDfj3FdjzzKI/qqTYrn178r2921h+b1r1CqE1fBXLNNq1Pi6WyPHKz7kplVjWo/s59jGrMsqmBzUCPBGjQBvxba0edyWRXbJYda/b0d/F+v/o4z/z8z/0SerlrWbD9hXsnOWJZZKZTzs9m0bq0V5b72cKFnOy02eV9HP/pyoq7ksKcsZfn5+2Lx5MyIiItCkSROUL18eY8eOxTvvvCPPadGiBZYsWYLPP/8cn376KR577DGsXbtWccKbKDvWJzQlIeRMTLVKedB15klPq1bB8PCnhWUbZpszp7btC60Xq1kpi4iIiIio2IuIiMCJEyewe/duxbj1e9oGDRqgYsWKeP7553Hx4kXUqFGjwOJh2wYiIqKSg6cPiYioNBo2bBj69u2Lp556Ck8//TS+++47JCcno3///q4OjYiIyKEik5RVrVo1RZKKRcOGDbFr165s1+3evTu6d+9eUKFRCWb7PyekzIpWarUy+9SZMoOWbFu1o6Qs2/aFiqQsoaicxaQsIiIiIqLibfDgwVi3bh3++usvuRp0Vpo1awYAuHDhAmrUqIGgoCD8888/ijmW9gyWlgxBQUEOWzb4+vo6rJIFsG0DUUnA0wVEREREVJq9/vrruH37NsaOHYuYmBg0btwYGzdutKskTUREVFTkrX4YUQlhkycFSQh5TKNSKSplOdO+0FIhy1GlLJPZtn1h5nVhc1vFRyYRUZ6xpQsREbmSEAKDBw/GmjVrsG3bNoSGhua4zpEjRwAAFStmlHcPCwvD8ePHERcXJ8+JioqCr68v6tatK8/ZunWrYjtRUVEICwvLp3tCRERExQHfAxMRUWkzePBgXLlyBQaDAfv375e/6ERERFQUMfWDSjXbSlmSVcUqtUoFrTrzIeJMpSzNw/mKtodypSzJbl+O9mvZNxEROY9Pm0REVFRERETg119/xZIlS+Dj44OYmBjExMQgNTUVAHDx4kVMnDgRhw4dQnR0NP744w/06dMHrVq1QsOGDQEA7du3R926ddG7d28cPXoUmzZtwueff46IiAi50tV7772HS5cuYeTIkThz5gzmzJmD5cuXY+jQoS6770RERERERERERESUiUlZVKrZV8pSti+0To7SaXL+xD/bSlk2O5Mk66Qs5bfa1EwuICLKJT5xEhFR0TB37lzEx8ejTZs2qFixonxZtmwZAMDNzQ1btmxB+/btUbt2bQwfPhxdu3bF//73P3kbGo0G69atg0ajQVhYGN566y306dMHEyZMkOeEhoZi/fr1iIqKQqNGjTBt2jT89NNPCA8PL/T7TERExYMASyoRERERERERFSatqwMgciXbk1HCqmKVRgVorRKxdFpnKmVlzFc7rJSVTftCVsoiIiIiIioRbKvx2goODsbOnTtz3E5ISAg2bNiQ7Zw2bdrg8OHDuYqPiIiIShYm2xERERERERVdrJRFpZrt5yWSyGwrqFarFG0IdWrnk7KUlbIy1rOrlGW1cyGUt5mTRURERERERERERFnh+UMiIiIiIqKij0lZVKrZJ2WJzPaFKpUiuUqndb59ocYqgcsyJmXTvlBAKCpnsVIWERERERERERGxBhIRERERERFR8cWkLCrVbMt7SyIzOUqtsqmUpclbpSxLK0P7SllW1yVlmxMmZRER5R1bNxARERFRSZVDh1QiKoX4vEBERERERFR0MSmLSjWbPKmMNoIPBzVqZXKVWy6SsqyTuSzbMGfTvtA6GQwA1MzJIiLKFeayEhERERERUWmi4hthIiIiIiKiIo9JWVSqCeGoUlZm+0LrNoS5qZRlnZSlkStlSXb7kuOwuc2TKkREucNnTSIiIiIiKgpO3IjHL/uuyF/6Iypo/E8jIiIiIiIqurSuDoDIlWzPj0kCMFu1L9Qq2hfm/JG/NjeVsqxytIRVMhjzsYiIiIiIiIjIEZ4zKPo6z9wNAPB152lXKlh8OiAiIiIiIir6WCmLSje79oXCqn2hSpFcpdM6XylL67BSVnbtCzNjUfMMKxERERERERFRsXYmJtHVIRARERERERGRizEpi0o1ya59IRQVq7RW1bF06pwfLtqHcxSVsjRZVMqyuplRKSvjupo5WUREREREREREROQM9i8kIiIiIiIqspiURaWa7TkLIYScPGVXKcuJ9oWWvC2NolJWxqB9UpayUlZmMhizsoiIiIiIiIiIiChrPIVIRERERERU9DEpi0o1R5WyLEMalUpuQ6hSKROtsmKplKVoX6jKuX2hsLrNSllERI9G8FvCRERERERERERERERERORiTMqiUs32g3tJCJitKlZZqlzpNGqnKlhZEreUlbKca18o5PaFzMoiIsot66dOo0lyXSBEREREREREhUiwfyEREREREVGRxaQsKtWEXaUsZftCS8UrN41zDxXLfEvFLOsxu0pZknX7QmFVKYtJWUREuaVC5nPn4Wv3XRgJERERERERUcGzfh9MRERERERERROTsqhUs/0emRCZiVpqq5aFOo1zJzkcVsrSWCplKSu3KNoXiszKWczJIiIiIiIiIiJH2KqbiGzxeYGIiIiIiKjoYlIWlWqSo0pZlqQsq0pZWicrZTlKypIrZZnt95V5HayURURERERERERERE7hKUQiIiIiIqKij0lZVKrZfpNMEoCloJVGpZKTq5xtX+iwUtbD67YJYGarwllCCEWFLiIiIiIiIiIiIiIiIiIiIiIqvpiURaWao0pZ1hWrtJrctS+UK2tZJ2U9/NqaSVLuS2TRvpCVsoiIHg1bNxCRs4QQGLrsCKZuOuPqUIiIiJxS3E4Z/LTrEtpP34nbiYYC2X6ywVwg2yUqTvgWmIiIiIiIqOhiUhaVarYf3AshYJYs7QszE6R0TlfKUj/8adW+8GFCl1nKrn1hZjKYqridYSUiKmKYlEVUPMUlpGHM6uM4eTO+0PZ54kYC1hy+gdnbLxbaPomIiEqTL9efxrnYJHy/9XyBbP/TNccLZLtExQHPIBIRERERERV9TMoisiKJzGQpjUqF4HKeAICqD3/mxJK7pWxfmDFoMtu0L7S6KZDZNpHtC4mIco/5rETF37DlR/HbP1fR6fvdhbZPg4nVNYiIiApDullyyX7XHL6Opf9cdcm+iYiIiKjk4md5RETkLK2rAyByJbv2hZLIbCOoVqFGgDe2Dm+NIF93p7bnsFKW2nGlLJFlpazc3QciIuI3hIlKgjMxCa4OgYiIiEoQo0nC0GVHAQAv1K0Af2+9iyMiKhiC5aKJiIgK3Qt1K2DTyVh82aW+q0MhIqIijklZVKrZnrOQRGbylKV1YY0Ab6e3Z0nA0ioqZWVcN2XTvhBWV9XMyiIiIiIiIiIieiTW511SjGb4uzAWogLBU4hEREQuY3mpyY/0iIgoJ2xfSKWabaUsYVWxKi+lRy0JWGoHlbJs92VdOUtS7Jev4IiIiIiIiIiIiIiIiIiKMhWzpImIKAdMyqJSzba4tyQyWhgCyhaEznq+TiBC/D3RtlagPCZXyjJLdvtS7JdZ9URE+YKNG4iIiIiopCoOXcpSjWaMXHkU287EujoUolKhGDwtEBERlTg8/hIRkbPYvpBKNSHsWwpakqPyUrHq2ccCsHNEW8WYJSnLLNlX5ZKvg5WyiIjyi+1zO5Vs8anpuJNkyFW7YSIiIiIqOD/8dRHLD17H8oPXH3lbs7dfwPpjt7D03ebwddflQ3TFD9/fUFYslTn4L0JEROQ6/EiPiIhywkpZVKrZnrSQhIA5n5Oj5EpZkm0CmNV1KfMkW17aJhIRlXYqvvsttZ76MgrPT9uJc7GJrg4lz0atPIZB/3eQH7gRERFRiRATn5Zv25q66SxO3UrAwr+j822bRCXFnSSDfD3JYHJhJERERKUPT+MREZGzmJRFpZpNnhTEI7YvdESrzniY2VbKsr39KBW6iIiKiq+++goqlQpDhgxxdShUSqSbMw6gu8/fcXEkebfs4DVEnYrFxdtJrg6FiIiIqEhKN0uuDiHX+EEdFTSTOfOfTOI/HBERUSHLOPbyEz0iIsoJk7KoVBNw1L4wfytWZVUpy7oahiSEnAzGnCwiKq4OHDiAH374AQ0bNnR1KETFkm2yOBEREZEtnjMgIiIiIio6+PqciIhywqQsKtUkmy9aSiKzgpU63yplZW5HkqwTsaz3K1gpi4iKtaSkJPTq1Qs//vgjypYt69JYmNdCVDiOX4/H9rNxrg7DjhACn605jhlbzrs6FCIiIiKX41mmksv6FCILZRERERUuHnuJiMhZTMqiUs1RpSzLCylNPiVHaTSZ27GulmXdvlCIzMpZTMoiouIoIiICnTp1Qrt27XKcazAYkJCQoLgQUfHz0qzd6L/gAC7EJbo6FIVzsUlYvP8qpm85l+NcvuwiIiIqPn7adQlzd1x0dRhERERERDIVU+CJiCgHTMqiUs02k10IAXM+J0dZV8oyS8qWhZnXMytn8cNBIipuli5din///ReRkZFOzY+MjISfn598CQ4Oztd4+C0losL15/GYfNlOfj1209LNTs9NTDPlz06JiIgoW496riPFaMaX609jysYzuJdszJ+giIiIiIjyiKegiYjIWUzKolLN9sM/ZfvC/NmHdXKXyapfovW+hRBykhYrZRFRcXLt2jV8/PHHWLx4Mdzd3Z1aZ8yYMYiPj5cv165dK+AoiYgcO3LtgatDICIiIidYf8nNaJKymUlUevAUIhERURHA4zEREeWASVlUqkkim/aF6oKtlGW22rewiiW/ksGIiArDoUOHEBcXhyeffBJarRZarRY7d+7E999/D61WC7PZvmKNXq+Hr6+v4vKoeDKaiIiIiIgoe2NWHVecm6LiTdEuiX9WIiKiQiXYroGIiJykdXUARK5k+5JJEsj39oXWyV2mLNsXZiaDsf80ERUnzz//PI4fP64Y69+/P2rXro1Ro0ZBo9EUShzK506+ISYiIiKikomf/dCjWH34BlrXCsArjSu7OhTKZ4Lvg4mIiFyCn+gREVFOmJRFpZptpSwhRGb7wnxKylKpVNCoVTBLQvFtRGX7QqtKWXwFR0TFiI+PD+rXr68Y8/Lygr+/v914QeIJaOJ/AOXFrvN3XB2CnV/3XUGIvyeefSzA1aEQEVERcuVusuKLXkR5FZ+a7uoQqAAwYZOIiKhw8dBLRETOYlIWlWq2Jyysk6byMznKUVKWWcqiUhZ7cBER5RpPQBNRXhy6ct/VISgcvnofn689AQCI/qqTi6MhIqKiwiwJtJ66AwCg16pdG0wh2H3hDl57soqrwyAq8ngKkYiIyPX4mR4REeWk5J/JIcqGbc9nkznztiYfs7K0D7dlm4iVGQcrZRFRybFjxw589913Lts/E7SoOBHCcRVNKp1uPkgrlP38tOsSPlh8CCazVCj7IyKiR5Nu9XxtMJX85+7V/95wdQhERERERNnieTwiInKWy5Oy1q9fj2bNmsHDwwNly5ZFly5dFMuvXr2KTp06wdPTE4GBgRgxYgRMJpNizo4dO/Dkk09Cr9ejZs2aWLhwYeHdASrWbF8zWbcCUOdjdpQlwcuUZftCAcui/GqbSERERET5yzahv7j6cv1pbDgeg00nY10dChEREVGR9tVXX0GlUmHIkCHyWFpaGiIiIuDv7w9vb2907doVsbGF/7qKpxCJiIhcj4djIiLKiUuTslatWoXevXujf//+OHr0KP7++2+8+eab8nKz2YxOnTrBaDRiz549WLRoERYuXIixY8fKcy5fvoxOnTqhbdu2OHLkCIYMGYK3334bmzZtcsVdomLG9nM1k5T5jdP8TI7SyJWyMrevrJqV+SEfk7KIiB5NyUiZoNKotL8ESE0358t2Cuo54K9zt9F00hZsO1NyEpmSjaacJxERERGVUgcOHMAPP/yAhg0bKsaHDh2K//3vf1ixYgV27tyJmzdv4rXXXiv0+FRWHwPzfTAREVHh4rGXiIic5bKkLJPJhI8//hhTp07Fe++9h8cffxx169ZFjx495DmbN2/GqVOn8Ouvv6Jx48bo2LEjJk6ciNmzZ8NoNAIA5s2bh9DQUEybNg116tTB4MGD0a1bN0yfPt1Vd42KEckmKyvdun1hPn4yqnVQKUvRvhCZlbJK+weyRER5wedOouIvxZg/SVkFpc9//8GdJCMGLDzo6lCIiIiIqIAlJSWhV69e+PHHH1G2bFl5PD4+Hj///DO+/fZbPPfcc2jSpAkWLFiAPXv2YN++fS6Lt6RUdCUiIiouLMdenpcmIqKcuCwp699//8WNGzegVqvxxBNPoGLFiujYsSNOnDghz9m7dy8aNGiAChUqyGPh4eFISEjAyZMn5Tnt2rVTbDs8PBx79+7Nct8GgwEJCQmKC5VOtucrrCtZ5ecLKbl9oVlZHcv6usRKWUREeaZioWgiIiIiIiohLt5OwrTNZ/EgxejqUEqtiIgIdOrUye6886FDh5Cenq4Yr127NqpWrVro56N5CpGIiMj1eDwmIqKcuCwp69KlSwCAcePG4fPPP8e6detQtmxZtGnTBvfu3QMAxMTEKBKyAMi3Y2Jisp2TkJCA1NRUh/uOjIyEn5+ffAkODs7X+0bFh+23yBSVstT5WSkr46GmqI5lc11OynJpU1EiIiIiIiIiovxWMj+tUhXQp3Dh0//CzG0X8NnaEzlPpny3dOlS/Pvvv4iMjLRbFhMTAzc3N5QpU0YxXqFCBfl8tSMFcT7a+r+PdbKIiIiIiIiKpnxP/xg9ejRUKlW2lzNnzkB6WJHos88+Q9euXeVSzyqVCitWrMjvsBTGjBmD+Ph4+XLt2rUC3R8VXbYnLMxSwbQv1DhoX2hWJGVlVu1ipSwiIqLcY7sO15u66Qy+3XzW1WEUayKbj9P+vnAH7/zfQcQmpBViRPnv2PUHGLP6OO4kGVwdChERUZFlOX905OoD1wZSCl27dg0ff/wxFi9eDHd393zbbkGcj65c1kO+rtfyW55ERESuwA4ORESUE21+b3D48OHo169ftnOqV6+OW7duAQDq1q0rj+v1elSvXh1Xr14FAAQFBeGff/5RrBsbGysvs/y0jFnP8fX1hYeHBxzR6/XQ6/XO3ykqsSSbD3BN5oJpX6h9mJRlnfQlWV+3qpRVUN+yJCIqLZibQ65w5W4y/jwRg97NQ+Clz/eX2EXe3SQDZm+/CAB4t3WNUvk7KGi9ftoPIOP15M/9mro4mrx7edbfADL+Z+b3ecrF0RAREREpHTp0CHFxcXjyySflMbPZjL/++guzZs3Cpk2bYDQa8eDBA0W1rNjYWPl8tSMFcT7a+oudPJ9IRERUuHgOmoiInJXvn5YEBAQgICAgx3lNmjSBXq/H2bNn8cwzzwAA0tPTER0djZCQEABAWFgYJk2ahLi4OAQGBgIAoqKi4OvrKydzhYWFYcOGDYptR0VFISwsLD/vFpVQti+a0h8mSqlV+XsyQ66UZVZWx5KvA5DkSln5tlsiolIpu0ozRAXlhel/wWiScO1eCia92sDV4RQ66xbQZheflSrpL6VuxRfvSlkWF+KSXB0CERFRqVTSXys9queffx7Hjx9XjPXv3x+1a9fGqFGjEBwcDJ1Oh61bt6Jr164AgLNnz+Lq1asuPR/NysFERESuwbxoIiLKicu+wu7r64v33nsPX3zxBYKDgxESEoKpU6cCALp37w4AaN++PerWrYvevXvj66+/RkxMDD7//HNERETI3yx67733MGvWLIwcORIDBgzAtm3bsHz5cqxfv95Vd42KEdtKWWY5KSt/X0VpHFTKsm1fKBXQvomISgM+dZKrGU0Z1Tb/uXwvz9vg5yj20s0SdBq2YiEiIqLip6h+WaRoRlV0+Pj4oH79+ooxLy8v+Pv7y+MDBw7EsGHDUK5cOfj6+uLDDz9EWFgYmjdv7oqQiYiIyAWK6ms9IiIqelz6CcfUqVPxxhtvoHfv3mjatCmuXLmCbdu2oWzZsgAAjUaDdevWQaPRICwsDG+99Rb69OmDCRMmyNsIDQ3F+vXrERUVhUaNGmHatGn46aefEB4e7qq7RcWI7Uum9IftC9X5XK5KrpQlZbZHtEsIE5lVuoiIKHf41EnFVWEkYpnMEk7dTCh2354/cu0BHvvsT3y35ZyrQykQKUaTonU2lRyRkZFo2rQpfHx8EBgYiC5duuDs2bOKOWlpaYiIiIC/vz+8vb3RtWtXxMbGKuZcvXoVnTp1gqenJwIDAzFixAiYTCbFnB07duDJJ5+EXq9HzZo1sXDhwoK+e0RERKXe9OnT0blzZ3Tt2hWtWrVCUFAQVq9e7eqwiIiIiIiIqAhyWaUsANDpdPjmm2/wzTffZDknJCTErj2hrTZt2uDw4cP5HR6VArYfTlraC2ryueSK1kGlLMnmc9HMZUwtICIiyg8bT8Rg5aHr+KZ7Q5TxdHN1OC4zatVxrPr3Ooa/8Dg+fP6xAtlHfGp6vm9z/P9OAgC+23IeQ9o9nu/btxWXmIZAH/d82ZYQAp+vPYFAH3d83M7+d56Qlo6G4zajajlP/DWyrTyu4uvAEmHnzp2IiIhA06ZNYTKZ8Omnn6J9+/Y4deoUvLy8AABDhw7F+vXrsWLFCvj5+WHw4MF47bXX8PfffwMAzGYzOnXqhKCgIOzZswe3bt1Cnz59oNPpMHnyZADA5cuX0alTJ7z33ntYvHgxtm7dirfffhsVK1bkl5SIiIjy0Y4dOxS33d3dMXv2bMyePds1AT1kffqyeH39goiIqPgrZt99JCIiF3JpUhaRq9m+aDJJBVOtylH7QknKqnVi/u6biKi04Rtisnjv10MAgKmbzmLSqw1cHE3OCqoN56p/rwMAZm2/UGBJWUv2XymQ7eZFXp8Czscm5VtS1rnYJCzefxUAHCZlHbpyHwBw9V6KPCaEwNRNZ/Jl/+RaGzduVNxeuHAhAgMDcejQIbRq1Qrx8fH4+eefsWTJEjz33HMAgAULFqBOnTrYt28fmjdvjs2bN+PUqVPYsmULKlSogMaNG2PixIkYNWoUxo0bBzc3N8ybNw+hoaGYNm0aAKBOnTrYvXs3pk+fzqQsIiIiIiIiokKgKqgTekREVGK4tH0hkavZVqsyFVD7Qq0646GmrJSVVVIWX8ARET0K5mSVTibbg7qVu0nGQoykdOLjTikt3ZzrdaJOxSL6bkrOE/MT/3CFIj4+HgBQrlw5AMChQ4eQnp6Odu3ayXNq166NqlWrYu/evQCAvXv3okGDBqhQoYI8Jzw8HAkJCTh58qQ8x3obljmWbRARERERERFRweAXg4mIyFlMyqJSzbZ9oSUxSpPPSVmW7ZmyaV9oSdJS81FJRESUa+uP3XJ1CESPJDbR4OoQ8uxeshGtvt6OaZvPujqUIkeSJAwZMgQtW7ZE/fr1AQAxMTFwc3NDmTJlFHMrVKiAmJgYeY51QpZluWVZdnMSEhKQmprqMB6DwYCEhATFhYiIiIon69bX/GCYiIjINVhmgYiIcsL0DyrVbBOj0guoWpVWo2xfaHZQzcOSsMVSp0RERLmXYjS5OoRSJS4xzdUhFAhJEjCYcl/lKje++P0E3vvlUIHuIztJhvx/rPy06xKu3kvBzG0X8n3bxV1ERAROnDiBpUuXujoUAEBkZCT8/PzkS3BwsKtDIqJSgqc6iIiIiKgkESw/TkRETmJSFpVyyhdNcvvCfD5baNleulnCtM1n8eTEKLs5bF9IRJR3fOokKlyL9111dQgF4uXZu9Fo/GYkpKVj+YFruHwnOd/3sWjvFRhMUr5v11lHrz3Il+0IIXDxdhKEEDDnoTRDaTh1OXjwYKxbtw7bt29HlSpV5PGgoCAYjUY8ePBAMT82NhZBQUHynNjYWLvllmXZzfH19YWHh4fDmMaMGYP4+Hj5cu3atUe6j0RUPN2KT8XMrecx7o+T2HPxjqvDISIiIiIqdiynQnhemoiIcsKkLCrVbAtWmeTEqPzdj5s246GWbhbYfjYO8anpdnPMBbRvIqLSwLrKoG1rWiLKWXxqOk7ddL6N2f7LdwswGtc5cSMBaekShi8/ipGrjqHtNztcFkuq0XHFrnx9hnuE153fRp3D89N2YtL60/kXTwkhhMDgwYOxZs0abNu2DaGhoYrlTZo0gU6nw9atW+Wxs2fP4urVqwgLCwMAhIWF4fjx44iLi5PnREVFwdfXF3Xr1pXnWG/DMseyDUf0ej18fX0VFyIqfd78cT+mRZ3Dwj3RePPH/a4Ox6HlB67h+PV4V4eRK2NWH+d7ESpU/BCYiIjI9VRsYEhERDlgUhaVarbnyiyVsjT5nBnlodMAAFLTzVl+wGZipSwiIqJir7h+DPfMlG148ftd+OfyPafm77uknFcQnz/eSTLk/0addDDaud+DM37adSlP69UZuxEdvvsLff/7D67dS8nTNs7HJuKDxYdwLjbR4fJ9l/KeXGdpVfjT7st53kZJFRERgV9//RVLliyBj48PYmJiEBMTg9TUVACAn58fBg4ciGHDhmH79u04dOgQ+vfvj7CwMDRv3hwA0L59e9StWxe9e/fG0aNHsWnTJnz++eeIiIiAXq8HALz33nu4dOkSRo4ciTNnzmDOnDlYvnw5hg4d6rL7TkTFQ0FUgsxvI1cdw0uzdrs6jFz569xtHC0GiWQ861RCFdc3IkRERMUUD71EROQsJmVRqSbZfIJYUIlRlqSstHQz0tIdt6uRHu6bOVlERESlkysLKySmmQAAW8/E5jCz8Fy7l+pw/HxsYr4mTVkU1O//y/WnEfnnaew4G5fzZBtnYhKx89xtDFl2JE/7fn3+Pmw4HoPXf9jrcPnqf28obg9ffhRvLzrIKh+PaO7cuYiPj0ebNm1QsWJF+bJs2TJ5zvTp09G5c2d07doVrVq1QlBQEFavXi0v12g0WLduHTQaDcLCwvDWW2+hT58+mDBhgjwnNDQU69evR1RUFBo1aoRp06bhp59+Qnh4eKHeXyIiypSW7viLeHnFYzIRUckXl5DmsLMGERUP/EyPiIhyonV1AESuZHtqy2R+mJSVz+mKHm4PK2UZzUjN4gQdK2UREREVjOM34pFulqDTFP73ESRJ4LO1J1C/si96NQvJdu7Oc3GoFeRTYLFYXmKYzBL+d+wmmlYrhyplPfN/P/m+ReCFb3fii5fq4ZnHyuOF6X8BAPaMfg6VyngUwN7y5v/Zu+/4KOr8f+CvTdskQEJPQDooRaUYFGMFRUDR07OcXeE8PfnB3Vfx9OBU7OIpYkWwIdhRDxsovUtogVACCQQSAiSbQsqmbd/fH5vZbK8zO1teTx88THZnZz6bbbOfec37/dbao6hu1OLlWy5wmpD7cPMJfLj5BEpemxzQuivUGq/LnKlrQZd2SUhuPRkAAGqadACA2mbvE/xGkxn/23saAFBythn9u7YLaKzu7C2txdLtJaKuM1z5cgA9OTkZCxYswIIFC9wu07dvX/z2228e1zN27Fjs27fP7zESERFR5OMMIlHkq2/R45JXLS3JA/2+SEQyYXaeiIh8xEpZFNMcD5gYTK3tC0UORiX70L5QqNolcudEIiKimHemrgVPfr9f1HVWqDWY9PYWfJFT4nG5TUcr8c2uUjz94yGX19vuieQcD7yVnD+WbC/B48v2Y+wbm0Rbp+2ukxRzUscqG3HfpzvtLit1aOlnNpvx2Lf78Nbao6Ju29eKF++sP4avdpaiqLJR1O37olDVgMtf24Br39wsyvocq8mK4dYPtuPnvDLR10tEREREgJlHhokiUlGl61bzRBQ5eEiPiIi8YSiLYprj8Sap2xc2e6qUZWSlLCIiMbDDB7nyk8hhkNdXFaJA1YBnf873uJy6xSDqdoPRupuDP4qqAVj2e77YcRJzfm4LjGndtFn2Jhz2XvaW1uGnvDJsPloV9LqE/TIAuOSVdX7dVmsI/d9wdb4KgCWAGCnC4TlDREQUi/h1iYiIiCh4DEQTEZGvGMqimOa409TWvlDkUFaS5aVW36Jzu4yxtUqXgqEsIiK/8Z2TQj0NojG4DlkH81yUeh9A5yIs9OxPh/B5zknr70siuL2c1s1jEogGbVuYTq0Jn2BduFLwXZiIKGxVqDUoqW4K6TalOEli2e5T4q+UKMJxDpEo9PaW1mKLCCcCRYpNhZWY/O5WHClXyz0UorDFj2MiIvKGoSyKaSaHY5NCpSyx2xcKlbJqmpxDWcKmjGxfSEQUOJv3zrpm9wFYii56Y9sHeUW9Bte+uQkLNhbJOCJnlQ0a68+nHNrtURs5Wv7FqkAPlKs1etz/6U58v4cHxYmIIsmYV9dj7LxNqHUxHxFJ3FUdJyILVowmCo1bP9iOBxbvQoVa433hKDDls93IL1Pj4c/3yD0UorDDz14iIvIVQ1kU0xz3mQxGoVqVuNtJbg1l1Tbp7S6PU7S1KzS2BsKYqiciCs63PIs+ZjRr2w7ONemMOF7VhDdWF8o4Ime/H1JZfzbFyGxNg8aAE1X+haxufn+bRKPxXTjvgzmObdHm4+g3ayW+E/H9ztvB7g82HsfWY9V48ocDom2TiIhCp+RsaKtlERERRbNKtVaU9UTKNIG6Re99IaKYFcYTSkREFBYYyqKY5nhw1FopS/T2ha2Vshyqt8QpFNbKWEIoKy6cjwgSERGRZMwizcZWqjV46of9OHi6XpT1+evy1zbgmjc342hFg8+3adIFXv2iUSt/e0GTyf6xk3Ji3Ww247XfCwAAT/3P/4CUY/tuwY97T3u8Xb3Ik/ARcuyBiIhEwpkOz347WI531x8TbX8QCO/AOYmDDzEREZF8OK9BRES+YiiLYpvDXpOhtZ+h6KEsa6Us51CWwlopq+0yIiIKXKScZUjRq6iyAUv+KLZrrwgARyuka9H3ydYT+OuS3dAZTHji+/34bs9p3PT+Nsz4eq9k2/Rm67HqgG/r+Ldz5801hbjgudVYe7gi6NkwT+8dqnrPrSl2nDjr0zY8BZs8XSfm+5pt9TZbBhPfPImIQi2/rB5//2IPiip9DzJTdPp/X+3F/LVHsbO4RvR1c5opNnBPjoiIKLSEMD33tYiIyJsEuQdAJCenSllGYSdKmkpZjge74uLaDrIZTdK0TiQiijXuqsAQiaGsrgX//t8B7Cutc3m9GcD4+VsAADqHYNHDn+/BvmevQ3y8AmnJiaKO6+WVRwAAP+07g6LKtvDXigPlom4nVM59+nevy5jNwHsbigAAz/+Sj6sHdwtqm6dqm91eN3+t57aYzQ6Vvtztzx064756Wahab24sqPS6jNlsxv5TdShUNWD8sAx0bpcUgpEREcWeP3+wHTqDCftP1WPHf66VezgktgC+lpxt1HlfiIiIiIiIiIgiBkNZFNMc58f0raGseJGDUUKlLEdxCoV1DK2bZqUsIqIAKNi4gUJk9vKDPleAevW3AnRxCLOMemktAKB47g1OIXAx4oTNOnla+bkKtDu238kvq8cv+8swfdwg0UNpALAmvyKo21c3aN1eJ2URKbPZLPoJAYGwHcG81UexKt9SUSttZQIOPD9RnkEREUU5ncES4FapPVdkpNgmdiVg+fc6SCxhsAtJREQUs4RdNH4cExGRN2xfSDHNsVKWUK1K7GCUUCnLkaV9oeO2Rd00EVFM4GQ0+ctsNmP78WpUeQjiuOLv8meb/K92YDSZ8eDiXXj+l3yflldr3Le9C0bp2WasyVc5hatc8WWZye9uw4ebT2Dub0fEGJ6rUUi0XmmdqG7yuoyY73G+rEoIZAGAWuMc9GtxqAxmy2w2Y8kfxdhdIn77JSIiolDT6I147udD2Hy0Su6hEBFRFIqUb7HhcCIRUbji64OIiLxhKItimuPxQ6F9YZzIySj3lbLaAmDWbXMHjogoKGKfSR7tzGYz/iiqxne7T6FRK0+VJTmsP1KJez7eictf2+DzbfRGEw6Xq0Udh6sw067iGmw+WoUl20t8Wsfw59eIOibBVW9sxCNf5GJjYVu7uw83H8eUz3YFtd7D5Q0426iFUcryUxFE79DmMhCh3nt0bBNbYVPhZf2RSjz/62HcsSgnxKMiIiKpGYwmfJFTgqLKBrmHEjJLtpdgac5JPLg4uP0fKZm4T0Xw7SQJIiIiEg8/eomIyFcMZVFMc5ywMJiE9oWhCWUBbZUPhKpdTNUTEQWH34f9s/JgOe79ZCee+t8BzPh6r9zDCRmh2oHOIRBzurYZn2w94TKg9uaao6Jtv1lnRO7JWru2eMJuicEUfEhHTLkna60/z/29AJsKg6sUcaRcjayX1+Guj8QN7TR7qN4USp525QKdsNPqw+s54ejHfWesPxf7UPmLiChU3lxTiG92lco9jKjxxY6TePbnfIyfv8Xv20bqPvqZ2ha5h+BRWV0LLn5lHeatLpR7KCQDziESERHJj5/GRETkDUNZFNMcJwWFg6BxIr8ykt20L9QZTdYdNiEQxvaFRETB4RnC/vntYLn152DDNtHg5vf/wMsrj+DFX51bBy7afFy07dz10Q7ctnA7vt3ddqBYoQBOnm3CAzJXYvjX9/uxbLfvB7DdveJWHVJBo3cOSukMlv2t3SW1Ttf54397T9v9Hmwoy9MxrcNl9hXSmkJcVa7Sz7aZnvAdkohixaEz9XhvQxFmLz8o91CiRt6pOrmHQA7eXX8MZ5t0eH9jkdxDISIiCmubj1Zhyme7UF4f3oFrihycXyEiIl8xlEUxzbHEu16iFoLuKmVp9CZrq0Sjie0LiYjEwC/E4Sm/rB67S2rcXt+g0WP+mkIcrZC3Hc7ZJh0A4I+is5Ju5+CZegDAD7ltwSIFgH9+m2dXTclVqMkTMZ7/P+Sexr//13YA+1RNYBOWe07W4pWVR0QYkWu2fzt3zGYzKm1a6wWqvkVv9/vrqwqCXqeYxHjcvVda4LsrEUUWtUbvfSGiMCfFpy8/0aMTH1ei6KI3mrDzxFloDeFREToaPLh4FzYVVmHW/xjYJ3HxkB4REXnDUBbFNHcTFmIHoxLj45DgpgSWcKmRlbKIiCjM1DXrMP3rvdhUWBn0uia/uw13LMpBlZuKP6+sPIJ3NxRhwltbcOmr63FM5nBWqBw4XW/3u2OA6MUVh/1ep9i7Enpj4K3zlu/1HpyS0gu/HsYlr65Hv1krUaBSe1x2yfYSt9eZHCrw5Tk8bo67joowLl7vbmSna5tDOg5WNSQiiiz7T9WhpjW8TkRERNJ6ecVh3PnRDvz7hwNyDwVAdIVOxKxETaFVUlKChx56CP3790dKSgoGDhyI5557DjqdTPuonNcgIiIfMZRFMc3kZp8pXoJklLtqWUIATGhf6L1KAREROeI7pzRe+70AKw+UY8pnu0VbZ4WbqkW27XBUag1bDbX6eqdzG8Gvd5Ziy9HwaTU5f+1RLM05KfcwXLINWk16e6vHZasb3U/ildfbP28Pnal3s2Rk2nK0Ch9vLZZ7GEREFKZyT9bg5gV/YOuxarmHQn7YW1on9xCIiMgLd5kO4Tv2T3llIRwNUXgrKCiAyWTChx9+iPz8fLz11ltYtGgR/vOf/8g6Lh7SIyIibxLkHgCRnNydoS9FC8HkpHg0aA1OlwshLBPbFxIRBczurZMnKfnFnyBKKBm9nG229nCF3639osGhM/X4z4+WwFrJa5P9vr3RXSLdA5745yyQv6M7of77lrl4XbsK/zlq1La93sQYM09EICIKrWDeurccDT6MFW3v+hsLKvHdnlP4zw1D/bpdoaoBXdonoWt7pUQja/Pr/jK8d/coybdD4YH77EREFO0mTZqESZMmWX8fMGAACgsLsXDhQsybNy/k4+FHLxER+YqhLIpp7iYspGgh6K5SlnA8qq1SlvjbJiKKJfxC7J99pbVyD8FvNU06PPz5Hsm3U6nWYNPRKvxpRE8ku/kcD7Wyupagbv/4sjxxBkJ2ClTh325zQ0EFGjTOJwj46tf9vp2hzX1ZIopmzToDUpM4leZNNH0WuLsvU5dYKsl6PLHO4aoTVY2Y+PYWAIGF64mIiCh4R8rVcg+BRFRfX4/OnTvLOgZF1J1+QEREYmP7QoppZjeH7kPbvtDyf5PZbPc7EREFxl0VRPKfSsZKWbYOnanHxoJKAMC2Y9W4+JV1Xm9z8LTn9nK+HCz88wfb8dQPB3DdW5vdtl0UUyDPXH+f77/4GKyJVkWVjZj+1V4UqMSdhH1jdaHd7+72MaXiy+7jX5fswf99myf1UIiIotbmo1UYNmc1/ruqQO6hUBjxZx8x96RvJ0MstWm/LAVOO0WXaApBEoU7MSsmE1HwioqK8N577+Hvf/+7x+W0Wi3UarXdPzFwCpqIiHzFUBbFNLeVsiRIRiUnuamU1TodZrRWyuJsChERuVfZoAlZ277CivCo/nPje9swdcluHK9qxH2f7vRpIvSm97cFvd0zrVWpTtW0YMyr64Nenzfu9kt+zjsDg9Hk83pctacLhhlmbC+qxnXzNwdwW3EFG7q875OdWHmwHLcvzBFpRP4R47UbCVW5iIii0Yu/5gMAFm46LvNIKNo990u+3EOgCBTqkwKIYtG6IxVyD4EoKs2aNQsKhcLjv4IC+xMjzpw5g0mTJuGOO+7Aww8/7HH9c+fORXp6uvVf7969RRm39bOXh/SIiMgL1lynmObumK7H8vMBSkl0nYEU8l/CAWYptk1EFEuieSr6TF0LLn9tA7p1UGL30+NFWaclHBwZf7WTZ5vkHoIs/u/bPPxRVI3Jw3t6XVaqs/Tu+WSnNCv208WvBBeOU7VWs2jUBt7GLxizlh+QZbveqDV6v5Y3+fFE23y0CjtPnPV3SEREJILaJp3cQ6AglddrUB4m1WuJiGJdMO3g3YmUau88YkFSeuKJJzBlyhSPywwYMMD6c1lZGcaNG4fLLrsMH330kdf1z549GzNnzrT+rlarRQtmAXx9EBGRdwxlUUxz275Qgr0od+0LhcpYbaEs8bdNRBTtFDHy9XfL0SoAQFWDVuaRhDdfJjXDdd7T3TP5uz2n8d2e03hy4uCQjifcVDeG33P/VE2z3e+ego7VjeF3cLxSrcH24/6FppbtPuX2OsfX1oOLdwUyLCIiCtLOE2dx50c75B5GxLP9XPvnN/vwnxuGIjM9OaB1rTnsXGFFazBiw5HKQIdHFEGn2BBFF7HOq+brlwjo1q0bunXr5tOyZ86cwbhx45CVlYXPPvsMcXHeG0IplUoolcpgh+kkXOcWiYgo/LB9IcU0YafJ8UuUJJWy3LUvZKUsIqKg8a0zcOHa5sJoMqO8viWg296+SJ7WdKFwoir01cKkDD2+ve4oVBFe/eG13wucLoukoOglAbTm9BTiOlHdGMxwiIhIJIs2s82i2H7ZX4Ynf9hvd9mek7Ueb7M6X2X9ea2LUNaba45i2ld7/R5LVYM2ZC3NKUKE59c6IiIi0Zw5cwZjx45Fnz59MG/ePFRVVUGlUkGlUnm/sYQUnJgmIiIvWCkrBPafqsNTPxzA05OH4qrzfEt7U2gIlTQS4hTQG9tmL+IkKFeV7KZSlhDCMraOhftvRETB4VlK/rH9/AsnB07XI3vuBrx/zyi/b5vr5eCYL87UBRYIC5a3R6PBzzZzgWzDUVGVdCGbt9cdw6pD8k6eBcsx2Hi2SYu05MSQbf+2hdtx+aCuIdseABz38Jz4Zpf7KlpERESRxnGO5uTZZtcLurG7xPV+qc5gQlJCHH7ad8bvMZXVteCy1pbm1w7p7vftiYiIiCLR2rVrUVRUhKKiIvTq1cvuOjlagXIOmoiIfMVKWSGwoaAShRUN+D3CDzhFo9biVE7VqeKlqJRlE8pKim976QmbMhhZKYuISAzhWvlJKq/+diSqKyG8ueao3EMImdIa7wf5bNve3LZwu99t5wAgv0zt1/JFldJWPipQNUi6/lC7/9Nd+OuS3T4vH+wkXu7JWmwulLbtUX2LfRjQ3wPSrsgxYUpERBQuvtxxEgDQovO/2tXWY20tzTmFRKzOQUREsWLKlCkwm80u/8mJn8REROQNQ1khoDeaAACG1v9T+BD21RIcKmP50Ibab7ahrI6pbdUTrJWyrO0Lxd82ERFFB8c5hqLKRny05YTL9mli23y0Cm+uKRSt1dyqQ+XoN2slblu4HSYTwxkAUFztX2vC3JO1uPeTnXaXqX2opBXKv3c0525yT9a4ve5sk86vdR08XR/UWIwS/6FHvLBG0vUTEUkhklrJhrOVB8rxzvpjcg8jMnn4eFapLfvUDVpDiAZDRERiEusrWKR8Z2YAlMhZhLx8iYgoDDCUFQKG1gNfBh5wDDum1m89ju0KpahWlZLUFsrqlJpk/VnYlNHNWIiIwtncuXNx8cUXo0OHDujevTtuueUWFBYWyjqmSJnQEkN9i3/BD1+Vnm1GjUOo5MHFu/DehiL87XPfKwB58uiXewFYgkV7S923G/Q3qOQrqeYT5T477+113g+a+hsYItduW5gj2roeWLzT+0IeHDrjX/UzIiIiX03/eq8k6z15tglj39iIb3aVSrL+YDVKHJYyyjhHGENfl2IKH1ciIiJ5MLNIRETeMJQVAtZKWQxlhR3hEXGqlCXBXlSym0pZwpaECTmedUJEkWTz5s2YPn06duzYgbVr10Kv12PChAloapImSOOLWAplfZFzUvR1Vqo1uOqNjbjopbUur5ci/GEwmUPyuFU3aiVZr5jVUMtFqkRGkaW22XuFMyIikhe/qwfH8c/37M/5KDnbjNnLD4q2jWadwToHF4yl20twwXOr8dVO//e1fd2n/XRbsd/rJnKF70xEoSP3SVhEFF74nkBERL5iKCsEDMbWSllsXxh2hJ2meIdQluPvYrBtX3jBOenWn9m+kIgi2apVqzBlyhScf/75GDFiBJYsWYLS0lLk5uaGdBy2b50NPrRvi0SnappxvKrR7jIpKh7ll8tTcaewosHrMsG2IXrHpoqURm8Mal22HFsIUujVNkdu9a///CjewWgiIqJIoTOIty8GWL4DDJuzGte+uTnodT33Sz4A4OkfD/l927s/3hH09okCwePCRERE8mDbdCIi8oahrBAwmCxhLL0xdN+OW3RG3L5wO95b772FTSwTJiwcQ1hSty98YsJ5uOvi3lgy9eK29oXWUBZ34IgoctXX1wMAOnfuHNoN27x3qjXSthqRg9lsxpWvb3Q6o97bxHukBMI9tS+0ZQ6yKcfqfBUAoLZJh+/2nA5qXbZ2FtdYf65US1ONizxr1ol7YDeU8k7VyT0EIqKoFOx+g9P6mHgIa3tL6wAApTXNoq431DM0Yj9vXeGsU3ThNCIRRZImrUHUk+SIiIiIIoGsoayjR4/i5ptvRteuXZGWloYrrrgCGzdutFumtLQUkydPRmpqKrp3744nn3wSBoP9wdZNmzbhoosuglKpxKBBg7BkyZIQ3gvvhDCWEM4Khf2n67DnZC2+3X0qZNuMRCahUpbCMZQl/raESlkpifFITUrAa7cNx9jB3a0hLOH5wUpZRBSpTCYTHnvsMVx++eW44IIL3C6n1WqhVqvt/pH4ztS14ILnV+PZn/w/w98XRpMZd32Ug1n/OxD0un7JKxNhRN5VNlgCU+sLKiXbRoM2+kKBYqhUR29bxnA7I9JgNMFoMuOUyAeliYgosoUqU1aoaojquajy+ha5h0DkUigCfUQkvlh67WoNRpz/3Gpc8Nxqht0pqjAgTURE3sgayrrxxhthMBiwYcMG5ObmYsSIEbjxxhuhUlmqGBiNRkyePBk6nQ7bt2/H0qVLsWTJEsyZM8e6juLiYkyePBnjxo1DXl4eHnvsMfztb3/D6tWr5bpbToQqFYYQVspq1lkOCDbywKBHwiMSHy99+8JkIZRlUzELABSte2xCZi/cDuwREflq+vTpOHToEL799luPy82dOxfp6enWf7179w7RCGPLx1tOQKM34YsdJyVZ/97SWuw4UeP3QbcnvtuP9UcqJBlTMMxmM/b5WLGLfCdMMI+dt0negUgo3CbRr/jvRkx6ewuufH2j94VlpOCsJRFRVLrroxyP19c06dBv1krsOFHjcTl/1EnYxtjxUz6UVfCJfMF5RCIKBTHeacrqLCdrGUxmGEz8PKXIx2whERH5SrZQVnV1NY4dO4ZZs2Zh+PDhOPfcc/Haa6+hubkZhw5ZKjqsWbMGhw8fxpdffomRI0fi+uuvx0svvYQFCxZAp7NMuCxatAj9+/fHm2++iaFDh2LGjBm4/fbb8dZbb8l115zoW3cw9SFsIdSktZSAFcJZ5Jq7SllSHCQSwlhCxSzrtlr/L1TK4vEpIopEM2bMwIoVK7Bx40b06tXL47KzZ89GfX299d+pUyKcSR+j34Ll/Mww2kyg/eXDHJ/LzxdWNOChpXvsLguHh++3gyr8+YPtcg8j6mj0Jvx+sDyi2wt6Eo5n96rUGhyrbJR7GEREFKNqm/Uer39/Q5Ho2xz54locPF0n+nqJiIiIiNwRTtLjIT0iIvJGtlBWly5dMHjwYHz++edoamqCwWDAhx9+iO7duyMrKwsAkJOTgwsvvBAZGRnW202cOBFqtRr5+fnWZcaPH2+37okTJyInx/2ZeaFum2StlBXC9L8QxtIbzdAaovMgmChaHxLHyljxErwyeqQnAwAyW/8viGvdlvD0iGMqi4giiNlsxowZM/Djjz9iw4YN6N+/v9fbKJVKpKWl2f0j8VU1akO2rV3FNXh3/bGQbU8KKw6EpoViLJr21V65hyCZzUer5B4CERHJbMeJs7hm3iZsL6qWeygRQao5qmCrw+4pqUG/WStx20KG9CkyheG5AkRERLGBh/SIiMgL2UJZCoUC69atw759+9ChQwckJydj/vz5WLVqFTp16gQAUKlUdoEsANbfhRaH7pZRq9VoaWlxue1Qt00S2haGMpQlVMpy/JnsWStlOYayJAhGnZfRAV88dAneuWuk3eWOZcbjZG0qSkTkn+nTp+PLL7/E119/jQ4dOkClUkGlUrn9DCZxtXioPrTyQHlA6wz0E/CX/c6hpgq1BpVqTYBrJAp/u0vEa70Ujf62dLfb68KxyhgRkSfuKmrf9dEOnKhuwj2f7AzxiORX16zD7OUHkHsy8j8Pb19kObkz96R47az9bfNNFBAeCCYiIpIFpzWIiMhXosc/Zs2aBYVC4fFfQUEBzGYzpk+fju7du2Pr1q3YtWsXbrnlFtx0000oLw/sIKKvJGmb5IFOqJQVwvaFtm0Lm7RsYeiO2U11KinaFwLAled2Q69OqXaXOeTBWCmLiCLKwoULUV9fj7Fjx6JHjx7Wf8uWLQvtQGL0vXOPm4NGCzaK3xbGm9O1LZjx9V4s2FiE2xduR3F1E8a8uh6XvLo+pC2cvfk8pwS7i+0PHP5+sDxWn0IxTYxQ0IKNxzkJ58G6I5VyD4GIiCT04orD+GbXKdy20H21+kgXzC5ifYvnVo7i4E4sWXCXlChCRfiL12gyh9WcD5EcHAsvEBEROUoQe4VPPPEEpkyZ4nGZAQMGYMOGDVixYgVqa2utbYs++OADrF27FkuXLsWsWbOQmZmJXbt22d22oqICAJCZmWn9v3CZ7TJpaWlISUlxuX2lUgmlUhnI3QuItVKWMYSVsmwqZzTpGMpyRyhelhDv2L4wdDtRjgEwqQJhRERSCJdKJ9H+zunvn/mN1YUBbyuYdmwrDpRjRWuFrmlf5lovb/ZStdPXjz4xJjnm/JzvdNm0r/Zi8oU9gl43RZavdpaKsp7fD6lEWU+sCY9PDyKi6BWKuYXi6ibJt0FEnkX7d2EiCg/udiuue2sz6pr12DH7WiQlsAUIxRbOaxARka9ED2V169YN3bp187pcc3MzACDOoVdbXFwcTCZLsj47OxuvvPIKKisr0b17dwDA2rVrkZaWhmHDhlmX+e233+zWsXbtWmRnZwd9X8RiaL0/elMIK2VpWSnLF+bW3SbHdoWhDWXZ/x7CTRMRETn57I8Sn5bz9nGlDkllAPGU1bPlZqz5fg9bCsnp5NlmGE3mkO53ExEREUWrcDlhiohiy4kqS0C75GwTzsvoIPNoiOTBOgtEROSNbNH17OxsdOrUCQ8++CD279+Po0eP4sknn0RxcTEmT54MAJgwYQKGDRuG+++/H/v378fq1avxzDPPYPr06dZKV48++ihOnDiBp556CgUFBfjggw/w3Xff4fHHH5frrjnRy10py011CqPJjF3FNWjRea5eEc2E+QrHg0Gh3IlybFfI9oVERCS2k2ebMPWzXdjl0LZPSpF2SGBfaZ3cQyCKOUfK1XIPgYiiWLi3Edl6LPDqpJHI0+Nx6wd/oK5ZJ/kYYnX+i1kd/yxcuBDDhw9HWloa0tLSkJ2djd9//916vUajwfTp09GlSxe0b98et912m1MXh1DiNCKRPPjaIyIGoomIyFeyhbK6du2KVatWobGxEddccw1Gjx6Nbdu24eeff8aIESMAAPHx8VixYgXi4+ORnZ2N++67Dw888ABefPFF63r69++PlStXYu3atRgxYgTefPNNfPLJJ5g4caJcd82JUCnLEMLe2s0675WyFm0+jr98mIN/frsvVMMKO8JOk2Moy7FylpQct8RiAURE0cFokueLed6pOqfLpn+9FxsLq/CXD3NE2463e1der7FZ1vPSvs5heFsPkT/0ITxhgoiIIp8vB12+2HESl766HkWVjQCAjQWVmPW/A05hoEJVA+7/dJck43Rnx4mzft8m92StBCNxtre0Dgs2Fvm8/D+/8X8ea3W+CkPnrMLCTcf9vi3Fll69euG1115Dbm4u9uzZg2uuuQY333wz8vMtbdAff/xx/Prrr/j++++xefNmlJWV4dZbb5V51ERERCQXHtIjIiJvRG9f6I/Ro0dj9erVHpfp27evU3tCR2PHjsW+feEbLBIqZBlCeHDWtjpWk5szAT/cbJmIWntYvrO55CY8Io6hrFBWq3LcloKn2RARRbz6Fj2umbcJV53XDXNvvRA/7juDcYO7IzM92ed1HK9qRH2LHhf16eTXtm9Z8IfTZWV1GhdLBu5YRYOo6/NV6dlmWbZL0ekwqzQREZHInv3pEADg6R8PYtnfszF1yW4AQM+OKfjntedalzvqZl9KbzRhd3ENRvXphJSkeADiBf3fWF2I6eMG+bx8k9aA2xZuF2Xbvmj2o4rVrhLP1V+rGrT4bs8p3DS8p/Wyl1ceAQD8d1UBpo0dGNggKSbcdNNNdr+/8sorWLhwIXbs2IFevXrh008/xddff41rrrkGAPDZZ59h6NCh2LFjBy699FI5hgyAFdGIIhVfukSRi69fIiLylayhrFihb62QFcpQli+VsvyZ8IpWJjeVsuJCWK7KMYPF9oVERJHv57wzONukw4/7zqBTahIW/1GMru2TsOeZ66zXL9p8ArdddA7+duUAl+u49s3NAIDts65BZprvYa5QuO6tLfj64TE+L79TpLaJe0JUrYGIiIhil8FowtkmHTKC2P8yOaQjVGrfAvJvrjmKRZuPY0C3dtjwxFio6jUYP38zbhzeI+CxBKpB43ouKRL8/Ys92Ftahx/3nZF7KGGB00yBMxqN+P7779HU1ITs7Gzk5uZCr9dj/Pjx1mWGDBmCPn36ICcnx2MoS6vVQqvVWn9Xq8U5QSDcW7USkWeRE6jkew2ROyy0QERE3sjWvjCWCGEsfQjbF9pWymp0E8oKZUgsXAlfeuLj7F8K8SHch3IOZYVu20RE0SLcvvvqDG2f+ZuOVgIAqht1AACN3oj/+zYPR8rVeHnlETRo9E63P3Sm3vpzydkmn868+uuS3fijqDq4gfvB5Mduzd+/yPV4vau/AREREZEc7vt0J8a8uh47Hdr9heJgyxc5JQCAE1VN2H68Gh9vPYFGrQHf7j4l+bajyd7SOgCwtpEk8tfBgwfRvn17KJVKPProo/jxxx8xbNgwqFQqJCUloWPHjnbLZ2RkQKVSeVzn3LlzkZ6ebv3Xu3dvCe8BERERSY6HWImIyEcMZYWAtX2hUZ5KWbY/kz0hl+YYwurULilkY3CsjMVKWUREke/jrSfcXqdzCGm72j84XdvStrzBhK92nvS6zQ0Flbj3k51el1txoAxjXl2HvaXBVZ36cMvxoG5vq6zet+oRPPOMiIiIAMtJb6vzVaht0om+7h0nLBU+v95V6nXZ6kat12UCtXwvqzwRyWXw4MHIy8vDzp07MW3aNDz44IM4fPhwUOucPXs26uvrrf9OnRInbMmvSEShw/wFEbnCz2IiIvKG7QtDoK19YQgrZdm0JrStmkWOhPaF9vnEnh1TQjYCxx027sAREUW+CrX7A3T1zf5Vhfpw8wnkOFRq8JfZph7+jK/3AQAeXroHuc9eF/A6tx4LXVUuAStqEREREQC8v6EI76w/hkHd22PdzKtlG0d5nW/BciKKLElJSRg0aBAAICsrC7t378Y777yDO++8EzqdDnV1dXbVsioqKpCZmelxnUqlEkqlUsphExERUQgxqElERL5ipawQaGtfaLY7KCqlZpuWhe7aF1Jb66V4h1dCZlpyyMbgWBmLVUCIiKKL47v66nz7thZ7TnquWBVsIMsdvdEEjT6ygtubCqvkHgIRkVdbtmzBTTfdhJ49e0KhUOCnn36yu37KlClQKBR2/yZNmmS3TE1NDe69916kpaWhY8eOeOihh9DYaN+G68CBA7jyyiuRnJyM3r174/XXX5f6rhGFjRUHygBY2tP9bekel3MtZh4mCUtGEx8XijwmkwlarRZZWVlITEzE+vXrrdcVFhaitLQU2dnZMo4QCNGUMxGJLFb3V/ieRdFA+A7CI3pEROQNQ1khoLdpUxSKySeTyYxmm4Os3toXtkuKl3pIYUv40pNgUylLoQAyQhjKcgxhxXEPjogoqji+zztWsDx4ui6Eo2mj1hgw5NlVsmybiCiaNTU1YcSIEViwYIHbZSZNmoTy8nLrv2+++cbu+nvvvRf5+flYu3YtVqxYgS1btuCRRx6xXq9WqzFhwgT07dsXubm5eOONN/D888/jo48+kux+EYWrdUcqUFzdJPcw7ETygcaNhZWSrv/b3eK0bCMLntcnvtmzZ2PLli0oKSnBwYMHMXv2bGzatAn33nsv0tPT8dBDD2HmzJnYuHEjcnNzMXXqVGRnZ+PSSy+VZbx8ChBRpOD7FUUr7o8REZE3bF8YAgZj22ycwWRGgg8ZKL3RhMXbinHlud0wrGeaX9vTGIx2E4CNLtoXGmyCYu2Usfs0EDJycTZJqK7tlUhKCF1e0XF/zbFyFhERRTbHd/W31h11WMD5fd+XjwK1H638WIWRiCh0rr/+elx//fUel1EqlW7bHB05cgSrVq3C7t27MXr0aADAe++9hxtuuAHz5s1Dz5498dVXX0Gn02Hx4sVISkrC+eefj7y8PMyfP98uvEUUaaobtejSLsnvfZdAz397f8MxLNtzCsunXY5uHdhWDACmfrYbJa9NDvnBpWBzbJ7ahxP5o7KyEg888ADKy8uRnp6O4cOHY/Xq1bjuOkvr97feegtxcXG47bbboNVqMXHiRHzwwQcyjzp2q+0QUWhwWonIGT95iYjIV6yUFQIGk8nmZ98+prcVVWPu7wWY+/sRv7fnWIGjyUX7wvqWtgO5KbFcKav14UiwCWX1SA9dlSzAuTIWv+AQEcUYV+12fNhdGP78GgkGQ0REobBp0yZ0794dgwcPxrRp03D2bFur2pycHHTs2NEayAKA8ePHIy4uDjt37rQuc9VVVyEpKcm6zMSJE1FYWIjaWvdtcbVaLdRqtd0/onCxsaASo19ehye+2+/y+p/zzmDp9hJRtzlvzVGcqmnBgo1Foq7XGykP4Gw7Vo0fck9LuIXAFFY0yD2EgIT65AYF64jI7tNPP0VJSQm0Wi0qKyuxbt06ayALAJKTk7FgwQLU1NSgqakJy5cvdxu0DgWegEMkj0iuiklEYuNnMRERecZQlsTMZjP0tpWybCpUeaJuDU3VNfteBUPg2K7QVSir1ma9Jpm/QZyqacZvB8thCkFrR0dCz2fb6lSZIWxdCLhqX8gdOCIif4XzwQvbt/U3Vhc4Xb++wL5FzKpDKvy6v0zUMZg5W0hEFDYmTZqEzz//HOvXr8d///tfbN68Gddffz2MRsvJNSqVCt27d7e7TUJCAjp37gyVSmVdJiMjw24Z4XdhGVfmzp2L9PR067/evXuLedeIgvLuhmMAgOX7zri8/v++zcNzv+Sj9Gyz6NuWe15ETPd9uhP/+n4/jlWGVwhqV3GN3EMgAeedolIUvY0RERFFBH72EhGRr2K3b12IGB2CRrYBLU90Bkt4S2twbj3ojVOlLJ2rSlm6tjEZ5N1zuPL1jQCA9+4ehZtG9AzptoV7blspq2fHlJCOwbFSFkNZRETRxTYwtmDjcafrK9RafLf7FPafrsNzN52PR7/MFX0MvlbqJCIi6d11113Wny+88EIMHz4cAwcOxKZNm3DttddKuu3Zs2dj5syZ1t/VajWDWRRxbCt/exJOoX05RlLJdn5EMSF83umIKL+sHn8UVWPq5f2RGO9bPYRIDnXwBEAiCx7SIyIibxjKkpjjQVDbVoYAoNEbcdvC7cjq2wkv3nyB9XKdUQhl+VZZy5ZjpaxmrXOwy7YCl97H6l1Syz1ZG/JQlnA2bJxNMiozxO0LnStlhXTzREQUoC9ySvDqbwW4blgGHr/uPPTv2i7gdT31vwMAgEsHdBFreHYaNM4BbSIiCg8DBgxA165dUVRUhGuvvRaZmZmorLSvomgwGFBTU2Ntj5SZmYmKigq7ZYTfPbVQUiqVUCqVIt8DotCL1kOAbEMWWwJtmxn0MXAeRCciksTkd7cBsJx0/bcrB8g8mtDiHgzFInPUfishIiKxsX2hxBwDTwaHSllFlY3IL1M7tSnSt4axNPoAKmXpLLdJS7Zk7hq9tC/UhUkoS5kY+qejMA9le+JKj1CHshx/5yQsEVFEePbnfLTojfhlfxnu+2QnANdnCbqqWOlOnY+VH4iIKHqcPn0aZ8+eRY8ePQAA2dnZqKurQ25uW+XEDRs2wGQyYcyYMdZltmzZAr2+7XNj7dq1GDx4MDp16hTaO0AUFsLrgIin0fx3VQH++c0+r+tQIPqyM9uLquUeAgCgQRMe+9xvrC50uszfg3vR9hyhwPGpQBQ+Dper5R6C6HjEgsg9vj6IiMgbhrIk5hjCcgxpCaErjd7ksJzldgFVymoNYXVPS7auw+Cw3bpmm/aFYRLKSk6ID/k2hUpZCXFtL4XMtNCGshzbFbJSFhFR5DlT14Lle0/j4lfWYV9prd11p2tbZBoVERHJobGxEXl5ecjLywMAFBcXIy8vD6WlpWhsbMSTTz6JHTt2oKSkBOvXr8fNN9+MQYMGYeLEiQCAoUOHYtKkSXj44Yexa9cu/PHHH5gxYwbuuusu9OxpqSx8zz33ICkpCQ899BDy8/OxbNkyvPPOO3atCYkoPC3c5NzOOhxJMTXx8dYTEqzVf6bwmAaTja8tQClCcB6RSBb+nIBHRNGJ4XgiIvIVQ1kS0zvM9Bgd2hkKYSyNwWhXXcPavlDv/0yRUCmrewel02UC+/aFodlzKKtrweJtxXaVu2zvc3Ji6ENZwtZtc1E9O6aEdAyOhbEcQ1pERBQZZn63H9WNOvy/r/b6dTu+7RMRRZc9e/Zg1KhRGDVqFABg5syZGDVqFObMmYP4+HgcOHAAf/rTn3DeeefhoYceQlZWFrZu3WrXVvCrr77CkCFDcO211+KGG27AFVdcgY8++sh6fXp6OtasWYPi4mJkZWXhiSeewJw5c/DII4+E/P4SRatw2EUrrWnyukyLzoiiysYQjCZ6hcvJir4wm83Yf7rO5+VzT9Y4XTZvzVERR0ThwlXVZiKSzm8Hy+UeArmxq7gGk97egt0lzp+BRFJg9xsiIvImQe4BRDvnSlmW3/8oqkaH5ARrpSyz2RLEUrZWi9IZ7MNavn6of7L1BDYfrQIAdExNRFJ8HHRGE5q0BqSnJFqXq2tpq5RlNJlhNJkRL3GJpvc3FuHrnaVITIjD/Zf2BQC02LRnTJahfaGQyrJtE9k9TelmYWk4V8riDhwRUSRr1Ph3tmRVg9b685yfD4k9HCKisKWq1+CCc9LlHoboxo4d6/HA6OrVq72uo3Pnzvj66689LjN8+HBs3brV7/ERkTOpv4UXVTaiWWdAapJ/03DrjlR6XWbi21tQWtOMbx+5FJcO6BLoEGUnZ57k7XWRE1L6ZX8Zvtl1yuflb1uYgw1PXC3hiEhunEUkkodYr71IiVNGyjgB4C8f5gAA7liUg5LXJss8GopmzEMTEZGvWClLYo6hLIPJhPoWPR5cvAtTPtsNjaEtDGTbwlColGU2+17Jqri6CS+vPIKtx6oBAKlJCUhVWkJeKrXG7sBAbbN9qXK90ST5mYG1TZYgWKVaY73M9sB1Ynzon45C+8LzMjrggnPSMHl4D2swLlQcM1jMZBER+S/Y906TyYzKBo3b6ysbNPg8pwQNGsvnp6fPzAZt4CXs+WWeiGJJURUruxBRePB0ItyxigY8uHhXUNWodhbX4Lr5W/y6zfJ9Z7wu8/vBcpTWNAMAVh6wr9jBuQXffbWz1K/lm4LY3w/Wz3llft/GxO8YMYEPM1F0aNDoMd3PCuyBaNIaRD0e5Mt7EN+nKFpxt5uIiLxhKEtEvx0sx+iX12Hal7nWy3QOO7Z6oxnqFj0MJjNqmnR2EzlavRGrDpWjuLoJekPb7bQG+9aD7rQ4tChslxSPdq1nYd76wXbMXn7Qel29Qyhr1SEVLnhuNX7O8z7pFyih+pe6pW3btq0MTTIciRY2mRgfhxX/uBIL7rko5GNwnPxlpSwiotD7x7f7cMkr67Gx0HU1gvs+2Yk5P+fjwufXYNy8TXjqhwMhHiERERFRdPPrm3AIpg+ETUz5bLe1InkwztS1+LW80YckzTSbg7a/HvA/rBPrnv8lH6+sPOz37WbZzK+JbcbX+/xanlNIxJZJsalJa0BRZYPcwyAJvLPuGFZK3BpRrdHj/OdWY+wbm3y+Dd9piIiIiALHUJaIjCYzqhu1qGlqaw1oMNmHsgxGE7Q2gSvbilV7S2vx6Jd78a/v99uFuWwraHniGABLVSagurGtJdK3u9vKm9u2LwSA7ceroTWYkHuy1uM2zGYzfj9YjpNnm7yO58DpOuSdqrP+LtzveptQVpO2LUjma0UwMQlBMDnnLxy7RsbxVUlEFHJCZYEPNx93ef3RirbKCMXVTfjRh8oFRETkGasDEpFY/H0/+SKnBBsLvLcGBPwPU1nGE/o3uDqHk+9CrULtvupsOKps0GDJ9hJ8vLXY6SRHb37dL18AriyA5yMRRZ/r5m/G+PlbsPPEWbmHQiKrbNB6XyhI+0rrAAS2j0NEbcxhcHyRiIgiA+MfIkpJtLS909iErpzbF5qtFaMAoLa5LRx18qyl5Hx1o9audKyvlbK0evvlUhPj0SM92fp79w7Ktu022U/WCRWrvJWs3X+6HtO+2uu1QojBaMKf3v8Dtyz4A3Wt91G4H2qbloUN2rZxGE3Stk90RXh05KxO5bhlBc87ISKS1enaZqw7XGH9Yj1bwjPhiYiIiMg/wX59P3SmHs/+nI+pS3aLM6Bo5eff+Z6Pd0gzDonYnhgYSRnhApX7yjjNOtdtFcfP3yzVcCiMMOweW8rqLUHYVfkqmUcSY/g6E42Zf0yKIjymR0RE3jCUJaKUpNZQls62+pNDpSyT2e6yOptwVI0QXtLbV9Oy/dkTx0pZJ2ua8fTkYbjgnDTLuGxCW2qNfSiroTUopTN43hkubz17osrLGRvNNts6Um6ZMArHSlnWJHvIt9zGMRDmWDmLiIhC64r/bsTfPt+DdUcs1RO+2VUq84iIiIiISCzl9dJXdAq0nZiY0wGhPjh0vMp7RXUSn+2Jn8PmrMb/fetf+0OKfKzOQZFKozdaT+aOZXJU15QL364o2sTOq5eIiILFUJaIkhMtf06NTWUrg8mhUpbRZBeesm0jKAS0tAajXUBJo/etUpbOIbx11XndcN2wDHz64MUALNWwzGYzzGYzmrT2Z88JoSxvlbIaWm/nLShmG0w7UW1p+aRtbcOotgllNdpVypIjlGX5v6yVshy2nRDPlyURkVxs58I+2XpCvoEQEcUAnh1NRIEIh2OXvs7TEEnth9zTdr//nCdfa0WSWxi8ORL5IXvueox8cS3ONkrfrk8KngLY/gSjHV+5fCUTRR4GpImIyBumP0SU3Nq+sMVDpSy90bF9oXOlLJ3BBJ1NsMvXSlnCcudltMfSv16CyRf2AAC0VyYAAExmoEVvRIveCCH/JLRc9LV9YWNreMvbBGSLzfWFKqFSltC+0DaUZRNg87JtKZiE2VwZd5ocd9iEx4SIiHwnxdv4zuIaFFW6bw9CRERERJ55m2OIVI8vy5N7CF4Fe3CoWRs7wTMeR6NIxucvRSrhuMje0jp5B0KyM5vN+PcPBzD39yNyD4XIL+FwsggREUUGhrJEJISybANLBoeWfAaTQ6UsmxK9ws9ag8muUpZQYcobIezVvUMyrj6vG+Jb++ClJsVbW+I1agzWAFacAkhLsQS2GlqDUl5DWVrfQlkamzELoSydy/aFbRW7HKuKhYKwRTkrZTm2K2Qoi4gofBw4XS/3EIiIiIgi0r7SWpz79O94d/0xuYciut8PqeQeglfBznIs33va+0IiCmXL8DfXFoZsW0ShwgPDRCQlKQ+fnKhuwrI9p/DhZlasJyIioujEUJaIUqyhrLZAksFkH3IyeKqU1aRrvY3ZrtqWbTtET4RKVMoE+4dVoVBYq2U1aA3WalftlAlIal1WuExn9PwN3hrK8lK9y65SVkUDzGaztZKXRm+yjlXYLiBP+0KT/IWynMoZJyfxZUlEJJdGh/a+REQkHR48JIpuz/2SDwCYv/aoT8t7agPkSOxWP2w54kyGKZqQ+TznJMw2H0J8/CmS+fPeSdHHnzZ5FJ60EdwSWazvc9FaWZWin5kNR4mIyEdMf4hIqJSlM5qsASO9Q8hJbzTZhbJsK2XZBrRsDwr7WykrKcH5Ye2QnAgAaLCplNVBmYDEeMuyTa0hML2XsJVQUctoMnvcWbatpFXXrEdlg9auDaO6xTIG2/vp+LcKBWESLk7GV4LttuMUQFI8X5ZERHLJL1PLPQQiIiIiCgPBHOY2M3Ua9mwfIk+hhrK6lhCMhoiIYtW764vkHoIoGA+kWMZ8NBERecP0h4hs284JoSTn9oX2YSbbIJJtQEsIPwFtFbC80XoIZQmVsmzbF7ZTJjgFgLydldBgU9nKUwvDFofrClQNdvdD3Xr/bNsXGk2hPyPCbK2UJd9ek+0ZbcmJ8TzDjYgojMhRxZGIiIiIIkM0f30P5L5tPVYl/kBktuZwhdxDIPIJv7lSpIrGj1J/quccLrc/OZDBbqLIwZcrERH5iqEsEdm2DRRCSU7tC0327Qtt2R73DaRSlhDKcmxfCADtk1tDWVq9tWVg++S2SlkCd6Gs7UXVKKlushuXxsO4HMvuHilX2wXQ1C361vHYVMqS4cC38AVJzolU203bBvuIiEh+e0pq5R4CEREREQXpw83HMentLaht0nlfmAJ2/6e75B5CQKI5XEfRj09fIiLxbCyoxKS3t+DQmXq5h0IRhK1kiYjIG4ayRBQXp7AGooQqUo4t+QxGE3Q+9Mi2rUjla6Usz+0LE6zrFYJQ7ZUJSIy331nQuWgheLhMjXs+2Ymx8zZZA12Af5WyHMu917sIZRllaF8oZObkrE4V51Api4iIQsv2s8jRsj2nQjgSIiIiIvImkK/vc38vQIGqAYu2HHdZgSLQAynRenZ8i863eSgiCh/R+n5EnjFUSoEIpBpXrIROpi7ZjQJVAx7+fI/cQ6EIwI9eIiLyVYLcA4g2KUnx0BpMNu0LHSplGc0+tULS2lTT0rqprOXuNsoE52CP0L6wQWOwBrHaKxOcqna5qpR1tKLB+rNdBS8PYbEWnf166pr1dr+rW8Nd9pWyZGhf2LrbFCdnpSybbackMZRFRBSIQCYiz9S14L+/F+CX/WXiD4iIiIiIJBPoV3i9wYwZX+/zb1sK8cIOKw6Ebr8zmJPP5q0pRCrnJ4giAkM5RBSJQh3yyjl+1q/lbYsTEHnDz2IiIvKGlbJEltwaiBJa+zm25NObfKuUZctTRSpbvlTKatQa0GBTKctxWVehLCHQBQCVDVqbcbm/H45jrm22bxEgVMpqsq2UJUP7QmGTcp7pYV8piy9JIqJQ+b9v9jGQRURERBSBHGcP/AlN+Tonk1+m9nvdtlT1GqfLvAbCRJya8FQN1pvdJTXiDcRGuFYT4HE0igbmsH2FUazytRpTIGGGX/eXYdLbW1Bc3eT/jUMgmGMNfCVL4+6Pd8g9BIpCrFJJRES+YgJEZEKloxYPlbIcq1N542ulLJ3Rss2keOeHVQhWNWoN1iBUO2UCEh2W1bvYVqJNcKumqS1c5U/7QiGEJVBbQ1ltyxlkCGUJ33LkTLLbVcpi+0IiopA5EaaTd0RERETRwN+DFP58LQ/0IKw/oYVjlY0er9cZTG4rX5kBvPb7EX+GRiFm+xwKpqoYkfz4/KXwYzCacP07W/HoF7mSrP8f3+xDgaoBT/2wX5L1++PTbcX4PKdE7mFEtFhpjUjRyPLdgruSRETkDUNZIlO2BphadEIoy37Cz2A0SRbK0rZWrlK6qLbUITkRgKV9oVB6tUNygrWVoUBndJ6gdDdeT5WytK2hLKHcvWOlLLVG3zqetrCWY4AtFEzmMGhfCNtKWQxlERGFim3QmIiIQs/Xs+eJKPJVqjWoDWDf69tdpbhu/macrm0WZRx7S+tcXt6kNWB3SQ1Mfpws9sGmIny45YTb6z3Nmbiy/Xi1X8u74s/4vfFlmiTvVJ1o2wu1BxbvknsIRERBC9ccwN7SOhSoGrAqXyXpdmxP+JZDTZMOL604jDk/5/vc7cQrfkUiijgMFhIRkTcJ3hchfwiVsoSdcL3JfhJObzL7HT7yuX1h63o9Vcpq0OitLQvbu6qU5WJsri7zNi6hUlan1CQ061pQ1+RcKctsNqNJ17YOOdoXtm1RzvaFbT+zUhYRkbTqW/SY8tku9O/aTu6hEBEREcWMS15dDwAoeW2yX7ebtfwgAODFXw97XK5CrUFxdRMmDMtAnIezrhocqngLlu05hWV7TuG/t13o89jW5Ff4vKwv7vl4Z/Dr+ES81jzeZmg2H62KmpYtPIxG0SBaXo8UHWLl5Avb4yOydAEJECtEEokjRt7qiIhIBKyUJbLkBMf2hfafykZTAO0LfTy7UlivMsFFKCvZx/aFRhNMJjNKqpusX57cjfd4VSOumbcJS7eXOF0nnBHauV0SAKChdZsCdYsBWoPJLoild1GlS2rmcKiUZbNtVsoiIpLWh5uPY19pHZbvPSP3UIiIiIii1rGKBhw8U+90ec7xswGtz7aCuKuDHw8s3oVHv8zFd3tOBbR+wc95rtsRRoodJ2pEWY8vB5jWHRY3lCYrHpumCMZsBUU6Pocjg9iPkz8tpYnCHd/HiIjIG4ayRCZUyhKCVI5VsfRGk7Wila+0Bt8qZWmtoSznYE+H1kpZjRoDGrXu2xfqjSZ8vPUExs7bhB/3WQ5YuxvvpsIqnKhuwq/7nSctrZWyWkNZjupb9GjQ2Ae15KiUJWxSzrND4my2zUpZRESB8eV9vLJBYw0mExGR/HhWKVH0uu6tLS4vv//T4KtBPfz5HrfXbT3W1gKQB0eIKJZwvyo28bMutEIRJArFNho0bZVDQzlPxucrRRt+9BIRka/YvlBkQqimxdq+0P5j2WA0Q2fw76Na42elrCQXlbI6JCcCsFTK0hs9tS80o6iyEQBQXN1kt15H1Y1a6zodCfe/c2qiy9uqNXqnHX53bRKlJDwS8lbKsgllJTGURUQkhdX5Kvz9i1y5h0FEREQU04wipAZUao0IIyE5hOuxWMeTBokiSbi+rii2+fNpr4iSZ3EktWxs0bUVAdAZTGinDH6dwdz7cKya5W5E9c16pCTFuzwGR7ErOt7FiIhIStxzEJky0fIn1VjbF9oHjQwmKStlWZbz1L6wwaZSlqv2hQDQpLNcL4zTWyjL1eSV1k2lLCF/pG7RO4W55KiUJXxZkvMsDbYvJCKS3jvrjsk9BCIiIiKSWahmHSLouCwRRYlwDDWQ9OTs/kDSHFOob9F7XygCNWoNUNV7D9aHc7itQq3BiBfX4Nr5m+QeCoWJcH6+EhFReGGlLJE5VcoyWj6UE+IUMJjM0BvN0PkYshJo3YSiHHmqlNVeKYSy9DCY4q2XuVpWCFnpWyt6uatgVdts+YLgqVJWF4dQVmZaMsrrNVCpNahssN8Jd6wqFgrmsGhf2PYz2xcSEUnjcLla7iEQERERkQc8rhxe+HAQRQa+d1LEi+DnsBR5jD+Kzoq/Uon4c/eHP78a7g7/REq1tM2FVQCAUzUtMo+Ewg0/i4mIyBtWyhKZUOlIaDkoBJqEsI3BaLIGtXwlVN1y1Kwz4PeD5WhurWyl9di+0BLKatQarKGrDskJSIx33lsQrjeYPFfKEjRqDU6JcOH+O1bKOjejA9KSE6DRm/DVjlIAQHqKpcWh0RT69oUmoVJWyLfcxvZLR3IiX5JEREREREREwXJ1oFTMs9lNHtYV6QdmpKq4s7H1YCYREVE0i6T9AF8/8b3dJW/Xy3A+PpHk+LQmIiJfSZYAeeWVV3DZZZchNTUVHTt2dLlMaWkpJk+ejNTUVHTv3h1PPvkkDAb7qkubNm3CRRddBKVSiUGDBmHJkiVO61mwYAH69euH5ORkjBkzBrt27ZLgHvkmxRrKEtoXWj6Wk5NaQ1kms9eQkyN3lbIWbTqOaV/txadbiwG0haeUCc7VloRKWSYz0NzaM9xd+0Kh8pUQKHNXKUtgNJmtISyB0Je8c6p9KCslMQ5ZfTsBANYXVAIAsgd0AdD2twolYQ41LlwqZSWxUhYRkZjMZrM1vExEREREkUmuAx4LNha5PbBaoGoI7WDCTCQdcCaKBeygRBR6/CwkIgu+GRARkWeShbJ0Oh3uuOMOTJs2zeX1RqMRkydPhk6nw/bt27F06VIsWbIEc+bMsS5TXFyMyZMnY9y4ccjLy8Njjz2Gv/3tb1i9erV1mWXLlmHmzJl47rnnsHfvXowYMQITJ05EZWWlVHfNI6HSkRBK0pscK2X5H8pq0Rux6pAKtU06u8t3nKgBAByvagTguVJWalK8XfgHsAS1XIWyGjSWtoS61vaFWi+hLABo0Nr3Ote0tmjs6BDKUibEW0NZgssGtYayZDhdwlopS8Z9JtvWiclsX0hEJJpPtxWj/+zfkPXSOrmHQkREREQIQWggyO/224/btwx6Y3VhcCuMYL8fUnm8/vOckyEaCRF5Eiltv0ga4frohyokGK6hKIYko5NUlUQpcvG1TkREvpIslPXCCy/g8ccfx4UXXujy+jVr1uDw4cP48ssvMXLkSFx//fV46aWXsGDBAuh0lvDRokWL0L9/f7z55psYOnQoZsyYgdtvvx1vvfWWdT3z58/Hww8/jKlTp2LYsGFYtGgRUlNTsXjxYqnumkfW9oUG+0pZ1lCWyeQUckr1Uh3pRFUTHv0yF0//dNB6mcFowsEz9QCAsnoNgLZQltJFKEuhUFirZQFAYrwCyoQ4JLmqlKWxr5TlS4hMaHko0FirccXbjScpIQ5ZfTtbf09PScSQzDQAlopbcpGzUpbtplMYyiIiEkWzzoCXVhwGYAk3ExFR+OH8JRFReGrSGnGsslHuYRARUQwI01wVhSkxW1ETBcscBkUfiIgoMkgWyvImJycHF154ITIyMqyXTZw4EWq1Gvn5+dZlxo8fb3e7iRMnIicnB4ClGldubq7dMnFxcRg/frx1GVe0Wi3UarXdP7EI7eeESlmG1kpZQvtCvdEMvUPIqWNKok/r3lRYZQ1IFVY0WA8yq1pDWbrWIJirSlkA0CG5bTvtlAlQKBRIjHfeW2gSqny5aV+YlpzgdJtGh1CWMLbkxHi70JkyIQ4jeqcjvrVs1+i+naxj8NYmUQrWSlkh33KbOFbKIiISXVWDVu4hEBEREVGIeftuH8hhvECO/e0rrcPRishtb1hc3ST3EIjIRzwQTLEsnPI5YTSUqLXyQDlGv7wOO06c9b6wH45WNGDz0Sq7y1yFv/JO1Yu6XYoe/CgmIiJvZAtlqVQqu0AWAOvvKpXK4zJqtRotLS2orq6G0Wh0uYywDlfmzp2L9PR067/evXuLcZcAAMkJQqUsIdBkbr3c8qc2mEzQOYSP0h1a/LnTrDNib2ktACDvVJ31clW9Bmaz2bpeV9WvAKBnx2Trz0LVrEQ3AS7L2F1XyuraQem0bKPWoVKWvq1to231J2VCPFKTEjCsh6U61uh+na0tFOWolCXsWyvkrJRl8zMrZRFRpFqwYAH69euH5ORkjBkzBrt27ZJ1PDtbW/wSEVH4CqeDKEQUG0L5vnOCwSYiCiHuVxFRoOb+fgTP/5LvcZlQHT/x9F42/eu9ONukwwOfijvnOOGtLXhw8S4cKfdcvOGbXaWibpciHz96iYjIV36FsmbNmgWFQuHxX0FBgVRjFc3s2bNRX19v/Xfq1CnR1i1UyhLa9xlag00pNpWyHENO6SnOlacAoIPS+fKtxyyJ/bzSOutlOqMJZ5t0be0LE10/rHdd3Mf6s1BNK9FNgMuyXssuhVMoq51zKMu2faHZbLarlJViWymrdWxPTRqMm0b0xN2X9LZWzRICbKFkCoPyonFxbRtPSZItJ0lEFLBly5Zh5syZeO6557B3716MGDECEydORGVlpWxjatIZvC9ERERERGFDwXPMiYj8xnfOGCfzE0BvNCHn+FloWo8FxLJIfS1q9EZ8uPkElmwvQYVaI8sYPB2bcVWxyiRRCjWSq5ySvOQs+kBERJHBrwTIE088gSNHjnj8N2DAAJ/WlZmZiYqKCrvLhN8zMzM9LpOWloaUlBR07doV8fHxLpcR1uGKUqlEWlqa3T+xJLeGjjQGoX2hZQdRqIBkMJqc2vSlJiW4rG7V3kWbwK3HqgEA+2wqZQHA6doW61kEynjX1ZZuGtHT+vOJKssZm+6qagGwtll0DEsN6+n897KtlKW1CXElJ8YhNantfihbw2BXntsN7909Ch1Tk5DQGkoymkLfvlC4Z3FyVsqy2TTbFxJRJJo/fz4efvhhTJ06FcOGDcOiRYuQmpqKxYsXyzam07Utsm2biIh8Y+Z5pUQkMm8HROSo0E1ERBStXl5xGHd/vANP/XDA7nJ/9vMZZpCX7b6R43EruX27qxRjXl3vtYIVkWz41YKIiHzkVyirW7duGDJkiMd/SUm+teLLzs7GwYMH7aporF27FmlpaRg2bJh1mfXr19vdbu3atcjOzgYAJCUlISsry24Zk8mE9evXW5cJNSFU09JaKUvYkRVCWUaTc6Ws5MQ4l9WtOrgIZR08U48KtQbHqxoBAD3TLS0JT55tK4uf5KYlYVJCHO662NKq8fJBXQB4rpRlaA1JCSGr524ahjWPX4Urz+3qtGyDRm/92fbMmGQX7QsdJcQLrR3lbF8Y8k1b2Z4NzFAWEUUanU6H3NxcjB8/3npZXFwcxo8fj5ycHJe30Wq1UKvVdv/E9um2YtHXSURERETycFUlIRBn6hjcJ6LoxLA7yWFpzkkAwC/7y+yviNKno6fdkUi6y5EShJu1/CAqG7T41/f75R4KkUeR8YoiIiI5SdYrrbS0FHl5eSgtLYXRaEReXh7y8vLQ2GgJE02YMAHDhg3D/fffj/3792P16tV45plnMH36dCiVlvZ4jz76KE6cOIGnnnoKBQUF+OCDD/Ddd9/h8ccft25n5syZ+Pjjj7F06VIcOXIE06ZNQ1NTE6ZOnSrVXfPIGsrSC+0LLbvjyS7aFwr7vskJ8dawUppNEKtDcqL159SkeJzTMQVmM7D9eDXMZkvVqQvOSQcAlFQ3W5d1F8oCgJdvuQBzb70Qc/88HACQGO9+d0FoXygEyzokJ+K8jA4ug0ONNu0LNXrL8glxCiTGx9m1L3Q1NqFSlkGG9oXCxK6cO0023QvtAmxERJGguroaRqMRGRkZdpdnZGRApVK5vM3cuXORnp5u/de7d++gx3FOx5Sg10FERKE1oFt7uYdARFHm1/1l+OuS3dDojbKefEVEFCqREq4gikbuWi8H+rJck+96Hs1Xi7cVY7EPJynaDk+OE+UBzwE3R6x0SuGKz0wiIvKVcykmkcyZMwdLly61/j5q1CgAwMaNGzF27FjEx8djxYoVmDZtGrKzs9GuXTs8+OCDePHFF6236d+/P1auXInHH38c77zzDnr16oVPPvkEEydOtC5z5513oqqqCnPmzIFKpcLIkSOxatUqp4PDoSKEaoRgkt6xfaHJBJ0QclImQK0xQJkYb2172KldEtStAadUmzBTRloyurVX4kxdC3JP1gIAenZMQc/Wg9AnayyVshLiFIiPc7/XnxAfh7sv6WP9PdFDgEtoXyiEyIQAV7KLql627QuFQJpwn+0rZbkIZcUL7QtDvwtjslbKkm8Cw/ZuM5RFRLFg9uzZmDlzpvV3tVoddDDLVRVHIiIKb+kpid4XIqKwc6KqEWfqWnDlud3kHopLGwoq8c2uUgztkSb3UIiIQkakgoJEIcdYYZtHvsgN+Lb1LXq8uOIwAOCO0b3sTvj3ZIVjlTMZyPX+lV9Wj0e/DPxv7orWYERNkw490nnyaCxhPpqIiLyRLJS1ZMkSLFmyxOMyffv2xW+//eZxmbFjx2Lfvn0el5kxYwZmzJjh7xAl0RbKEipl2bcvNBjN1lBWemoi1BoDkhPjrNWnOqYk4mTrupJsWgtmpCmRmWZpVZh7sg4A0CM9GZnW9oWWSlmuQk+eJHloXyhUyBLGK6zbVQvCBttQVmvrRmXrfbINl7kanxAi05vs2zrqDCZoDEak+fgFIhBCaW85d5q0hrZ2j7ZVxYiIIkHXrl0RHx+PiooKu8srKiqQmZnp8jZKpdJaFVMsXdqLuz4iIiIicu2aNzcDAFb84wpr9e5w02QzR0FERBSt3FVqiiSRGmZQKMKrbahwYj3gX0eSJl3bsQmxw1H/XVWAospGfHhflrgr9uCLnBKfl53+1V6cqhG3tfWkt7eiuLoJqx67EkMyeYJAtBOrxToREUU/ydoXxqpkp1BWa/vC1upSGr3RunMrhI2SbSplpacmWdeVaBOYykxLRo/WqliFKrXlsvRk9LCGsiyVsjy1LnQl0YdQlvB/YVmv7QtbQ0YpSXGt/7cJZbm4bWKcZTmzGTDZlI2675OduPy1DWjQ6H27MwEQcmBxMn77s/3C5G+ojohIbklJScjKysL69eutl5lMJqxfvx7Z2dkyjoyIiIiIpHS4XC33EIiIiGJauAaaQhVTCNf7H0mk/Bsu3HQcaw9XYFdJjc+3Cea5c/JsE579Od/n5bUGk9vrAh1HcbXlON1vB4NrRUmRJRoCskREJC0mQETW1qbQDL3RZK3+JASZbM88ENp1JCfEIzmhrVKWwDZglZGWbG1VKOSWeqanWKtnVTfqnG7jC6EloSv61kCZEBoS1u2qfaFtcEqj8699YbzNGGyrZR0pV6NBY4CqXuP9jgRJzl0modUlIG8bRSKiQM2cORMff/wxli5diiNHjmDatGloamrC1KlT5R4aERGFMZ5VSkRSyi9jaMyVZh2riBFFI+5VEQFGkxl3LNqOp37YL8n6bV9nZnPkBjFs70cw98DX73PCSf/uiHVIpK5ZupP7/cbvujGBjzIREfmKoSyRKW0CSxq90VopS6gWZTv5ZQ1lJcZZr++U2hbKSoyPQwelpcPkpAsycU7HZLttWSpl2femdtVa0BNPlbJ0Du0LkzxVytI6V8pK9rF9YUJc21630aZSlrBdo4Q7sMIXBzkrZdm2LyQiikR33nkn5s2bhzlz5mDkyJHIy8vDqlWrkJGRIffQiIiIiCjMNGkNuP/Tnfhix0n7Kzx8Ld96rNrv7by04rDft4kFmwqr5B4CEYmI53eS1IwmMzYfrUJ9OAVe3NhdUoPdJbX4bs9puYciq7VHKkK+Tb4XUSzj85+IiLxhKEtkyoQ46wdwi94IQ2uwSKgWJVSfilMIQasUXD6oK24eeQ6G9UjDNUPbDmAnJSiw7omr8b9pl2FUn07WSlmCnh2TkZGutLvM30pZnpYXzmAQKmUlJjiHsjq2hsgabNoXtujsq4OlJCV43F5CXNtlBptQlrB926CW2IRVy7nT5KlMLhFRpJgxYwZOnjwJrVaLnTt3YsyYMXIPiYiIiIjC0JLtJdh6rBrP/nTI7TKPL8tjNT0iIj/wPTM2hWJK+7M/ivHg4l24deEfkqxfzGpTJgmPI0SSp3444PF62794OPzFbN++bE/+d8cUAe934T9CEkMEPBWJiChMMJQlMoVCYW1FqNGZoG/9IpDiUF0qKSEON488B3/MugYXnJOO27N64bf/uxIDurZrWyY+Dhlpycjq2wkAnKpiZaalQJkQj67tk6yXuapE5YltlSrHVoYGx/aFQqUsm20I7RPtKmXp7StlpdhUD3NVyct2DMI2DUaTNTAlZSjL3Lp7zFAWEVH02vivsXIPgYiIXMhMT/a+EBFFHV8Otv247wxO17YEvI2wal9DRCQhVucgqf26vwwAcLyqSeaROHMMRMiZj4iESmKu+BoqkfK9xjZkVanW4ExdC95ed9TD8tKNhcgfZsbviIjIRwxlSUBoRagxtFXKSk5yCGW5aRtoG6pybC2YlpyA9sq2qlM9W9sZ2h7M8LdSlu02bNcNtLUPFCpWCWNLiI+zBql6pDuHslpaQ1lCGCvVplKWq9BYXJwCQi7LYBK22bYzE5JKWTL2f9fq2b6QiEhK/W0Cz0REFD46t0vyvhARRR1hnsSbYKogfLKtOODbElFsmzt3Li6++GJ06NAB3bt3xy233ILCwkK7ZTQaDaZPn44uXbqgffv2uO2221BREfp2YbZ4WJjCSSxWj7ny9Y3Wn+W4/1IHNOtbPIfOxLzPf1mUg7fXHRNvhTKIxddALGNAmoiIvGEoSwLpKZaWfqp6jbXyk6tKWa7YVpJyXEahUFiDWCmJ8dbtZKa1VdByF/Zyx3YbHZIT7a7TG00wm81t7Qtt1i1UwerR2lKxUWOwlsl2rJRlG0hLTnQ9PqGFobU6l80krZTlaIVVx8n4StCwUhYRkeQeyO4r9xCIiIiIoprOYMJnfxSjqLLB43Ifb2VgiojC1+bNmzF9+nTs2LEDa9euhV6vx4QJE9DU1FYl6PHHH8evv/6K77//Hps3b0ZZWRluvfVWWcYr54mmFBsiKVvCIIx0GjTeK52K5Uxd4NVSwwUrKMUGvucQEZGvGMqSwMjeHQEAGwsr0aSz7KwKASqB20pZie4rZQFAz9YQVI/0ZCgU9tWqLLd3bg/oiadKWWazpUqVEJCyDXAJ4aqerds2mMzQ6C3LNWmFSlmWsaTajMlV+0IASGhtnShUxdLbhLJ8PIk2IEKQjJWyiIii0+ThPQAAT08eivfvGSXzaIiIiIii16fbivHCr4cxfv4WuYdCRBSwVatWYcqUKTj//PMxYsQILFmyBKWlpcjNzQUA1NfX49NPP8X8+fNxzTXXICsrC5999hm2b9+OHTt2yDx6ijXRUJ0lGu6Do3C/T+E8Pl8zLn9dshuVao2o227WiXec5ofc09biBSQNrVaLkSNHQqFQIC8vT9axKML5RUVERGGBoSwJjO7XCQDw9c5SmMzAgK7t7IJTgPtKWbZhLVfL9EhvDWV1bFufXftCPytlJca37Sx0SE5wul5nNFlbCdoGuIRwVfcOydad+AatpYTtobJ6AEC/1nZRqUm2oSzX44tv7V+od2iZCEjbvlBYc5yM+0xXntsVANBB6fz3JyKi4Dx0RX8Als+tG4f3xIf3Z8k8IiIiErCyA1F02VdaK/cQiIhEV19vmefs3LkzACA3Nxd6vR7jx4+3LjNkyBD06dMHOTk5btej1WqhVqvt/omJ1TooFMwSPNHE7JLhWJ2otkmHf32/HztPnBVtG9EmFBWdyrxUvvKWZylQNeB0bbPdZRsKKjHn53y/1uO0XYffP9pywvpzsE/LCrUW/11VENxKyKOnnnoKPXv2lHUM/OglIiJfMZQlgUv6Wb6ka1vb0l09uBsSHMJSrqpgAUBcnMIarHIVsOrfNRUA0KdzqvWynh1tK2X5G8qybV/oHAoSql4BritldUhOsFbYatQYYDKZsbukBgAwpr/l72DbvtBdGC0hzqFSlqFtd0bKUJbwpU/OIPsjVw3EG7cPx+rHr5JvEEREUarF4Sy37IFdZBoJERHFii1btuCmm25Cz549oVAo8NNPP9ldbzabMWfOHPTo0QMpKSkYP348jh07ZrdMTU0N7r33XqSlpaFjx4546KGH0NjYaLfMgQMHcOWVVyI5ORm9e/fG66+/LvVdI5IUY5qhwb8zke9MJhMee+wxXH755bjgggsAACqVCklJSejYsaPdshkZGVCpVG7XNXfuXKSnp1v/9e7dW5QxsjgHSc02nPLrgXLR17+xoCrg23p7/r+88gh+yD2NOz+SpopdpL7+pAhxCsfCXPlx35mg1z/9q71Ol1U1aoNer60KkStvrT1cIer6qM3vv/+ONWvWYN68eXIPBQD3r4mIyDuGsiQwsFt7dExta1c4bnB3KBPi7HbS3YWTbK+zrWIluPPiPvj3pCGYcc251ssy01KsPyv9rpTlvn0hADTr2nqF21a5Etoo9u6cirRky32ta9HjWGUj6pr1SEmMxwXnpANwrJTlrn2hZd2G1gCWzrZSloSnegmrlrO8aFJCHO4Y3dv6NyUiIvEM7ZFm93taciLWP3E1RvftJNOIiIgo2jU1NWHEiBFYsGCBy+tff/11vPvuu1i0aBF27tyJdu3aYeLEidBo2g4C3HvvvcjPz8fatWuxYsUKbNmyBY888oj1erVajQkTJqBv377Izc3FG2+8geeffx4fffSR5PePiIgoVkyfPh2HDh3Ct99+G/S6Zs+ejfr6euu/U6dOiTBCW6zXQdKwraS05ahvASp/qi/ZHn8QW2lNk2TrDjdnG3Wybn/9kUq314lRIbmostH7QiFmNpsxb3UhfmoNnUlZXIDaVFRU4OGHH8YXX3yB1NRU7zeAhNUq+ZATEZGP2C9NAnFxCozu2xnrjlQgJTEel/TvjMT4OGSmJaO83jLR7imUpUyIQ6MWSHIRYEpPScS0sQPtLrNtjehpva7ExynQXpmAJp0BXdorna63rZRlG+Cad8cIFFU24oJz0tEjPRln6lqgqtfgbJNl5z+rbyfr8imJvlfKMrS2SrRtX2gKRaUsybZARERy6twuyemygd3ao1enFOw5yRY7REQkvuuvvx7XX3+9y+vMZjPefvttPPPMM7j55psBAJ9//jkyMjLw008/4a677sKRI0ewatUq7N69G6NHjwYAvPfee7jhhhswb9489OzZE1999RV0Oh0WL16MpKQknH/++cjLy8P8+fPtwltE4c5gNDlVFiciCgczZsywBqN79eplvTwzMxM6nQ51dXV21bIqKiqQmZnpdn1KpRJKpfPca7A4p0nhyJ9zrMU8VzqW23h+vPWE94VaeToJfv2RCnTvkIwLe6X7tf1g2iDaDkfdog94PaG2s7gG728sAmA5Hjbx7S0yjyj6mc1mTJkyBY8++ihGjx6NkpISn243d+5cvPDCC5KNK1Kr5hERUehw5ksiQnukywd1RXJrKKl3p7bUtrv2hUBbRSpXlbJcybQJZSn9DGUBwLt3j8T8v4xARpqLUFbrmSrxcQrEx7WNJyMtGZcP6gqgrWpWWV0LdhVbWhde3NrCEQC6tlciNSkePdOT7dZhK6H1vhpMljCWbShL0jMMWlcdx70mIqKYksVKWUREJIPi4mKoVCqMHz/eell6ejrGjBmDnJwcAEBOTg46duxoDWQBwPjx4xEXF4edO3dal7nqqquQlNQWPp44cSIKCwtRW8vQMUWOr3eVyj0EIiI7ZrMZM2bMwI8//ogNGzagf//+dtdnZWUhMTER69evt15WWFiI0tJSZGdnh3q4VrEcRollYlQg8kbq55aY63dcVSy9Lkx+3Nnle09bf7Z9Dh2rbMBDS/fgpve3iTo2fzyweJfPyzo++4N9vP29fW1TW3Wyd9YfQ7PO6HZZs9mMI+Vqu+Ne1GbWrFlQKBQe/xUUFOC9995DQ0MDZs+e7df6papWGUwYkYiIYgsrZUnkvkv7QAFg0gVtZ0j16pyCXSWWnz2Fp5StIS5fq14lJ8ajU2oiapv1flfKAoBrhmQAAD77o9jpuiatJZSV5CFEJoSyztS1YHdrKOuS/m2hrHbKBKz855VITnS/joQ4+/aF+hC1L7RWymImi4goptx9SR98uaMUhRUNePTqgVi0+bjcQyIiohigUqkAABkZGXaXZ2RkWK9TqVTo3r273fUJCQno3Lmz3TKOB4mFdapUKnTq5Dp8rNVqodVqrb+L1raBKEBHyhvcXidUGiciCqXp06fj66+/xs8//4wOHTpYP3vT09ORkpKC9PR0PPTQQ5g5cyY6d+6MtLQ0/OMf/0B2djYuvfTSkI9XwUlNijJmsxmPL8vDwG7t8Y9rz/X7tlKKpJDXz3lnMH5oBtopnQ8B1ja1VaOyfQs5URV4u0ex/jaegk1SCyZg4+qd2PYY1+c5J/HcL/m4blgGPn5gtIulY9sTTzyBKVOmeFxmwIAB2LBhA3JycpwqT44ePRr33nsvli5d6vK2UlWrFIQiIEtERJGNoSyJKBPi8dcr7CfJ+3Ruq5TlKeQkBLY8LeMoMz0l4FCWwFX1LqF9oaeqXed0tFTqOlymhkptmTR1LG/bv2s7j9t2bF+oM7TtAEvZvlBYMytlERFFvhG9O2L/qTqflk2Ij8Pqx6+y/s5QFhERxQKp2zZQbBP7a/VdH+0Qd4VERD5YuHAhAGDs2LF2l3/22WfWA8ZvvfUW4uLicNttt0Gr1WLixIn44IMPQjxSoui040QNfsorAwC/QlmVDRq8v6FIqmE5CffDCf/3bR5uuDATH9yb5XSd7dj9CVNp9EZrVxijyYxV+apghxlWNHrXVazK6lrQvYNzoKe0ptn6s6vnQ4W67WQYob3k2sMVQY4yOnXr1g3dunXzuty7776Ll19+2fp7WVkZJk6ciGXLlmHMmDFSDtGlSApqEhGRvBjKCiFf2xd2SLY8LO2TfX94eqYn40i5GsqE+IDH5yoEJrQvTPKwXqFSVu5JS5uMczqmoL2LMzA8EdoaumpfaJAwlOVPWV8iIgpvjvMfPW3a+xIRUfiJxVL/mZmWSsoVFRXo0aOH9fKKigqMHDnSukxlZaXd7QwGA2pqaqy3z8zMREWF/YS+8LuwjCuzZ8/GzJkzrb+r1Wr07t078DtEJKKdrZW3SVrhfhCZSG6+VNpJTk7GggULsGDBghCMyDext1dFQGje021fEr5OpfvzfHS8Dxp9YJWS/rZ0Dw6crg94HNHot4OuQ1N2j6kff6WLX1mHg89PBAB8ucNS+UkQzHMxmNt+kVOCYT3TkdXXdaXgQLXojdhXWovaZh3+umSPy2Xm/l5g/ZmVkkKjT58+dr+3b98eADBw4ED06tVLjiEB4P41ERF5x1BWCPW2rZTloaLVvycNwZajVbh0QBef1z2id0esL6jEgG6eK1J5kpjgvOfQ1r7Q/V6FEMoSwlMDu7f3e9sJ8UIoy7l9oZTBKWHV3GkiIop8jp8Wy/6eHfQ6L+7XCbtLaoNeDxEREQD0798fmZmZWL9+vTWEpVarsXPnTkybNg0AkJ2djbq6OuTm5iIry3Jm+4YNG2Aymaxn/2ZnZ+Ppp5+GXq9HYmIiAGDt2rUYPHiw29aFgPRtG4gCledjtVMiIrLHKc3YFuuPv+1hA8dAVii4+/vL8bgEHAry49BLg8Zg/XlDQaWHJUNjz8la7GktFDD31guxu0TcgP+fP9ju87Leji+drm0JcjQUjmI9+ElERL5jKCuEendOsf4sVIZyZXS/zhjdr7Nf654xbhBuHtkTfbsEEcpy2b5QqJTlPkQmhLIEg7oFEMqKs6zfaHQOZRmlbF/Yumq2LyQiii7PTB5qF4YO1DkdU7AbDGUREZHvGhsbUVTU1jqluLgYeXl56Ny5M/r06YPHHnsML7/8Ms4991z0798fzz77LHr27IlbbrkFADB06FBMmjQJDz/8MBYtWgS9Xo8ZM2bgrrvuQs+ePQEA99xzD1544QU89NBD+Pe//41Dhw7hnXfewVtvvSXHXaZYJeJX9QOn68RbGRFRDGIzALLVpDXgxV8P44bhPXD1ed5bgoWTcK6m6zi2cBpprB/emL38oN+3UYj4R4v1v79c+vXr51OFS6kI2+bDT0RE3rhP2pDoMjq0tVE626QTdd1xcYqgAlmAm1CWzlIu2FMoKy05wa5d4bkZgYSy7NsX6oxtO1KShrJavzpxp5mIKArYfAn/25UDRFllr07BB7uIiMi1+CjdCd+zZw9GjRqFUaNGAQBmzpyJUaNGYc6cOQCAp556Cv/4xz/wyCOP4OKLL0ZjYyNWrVqF5OS274tfffUVhgwZgmuvvRY33HADrrjiCnz00UfW69PT07FmzRoUFxcjKysLTzzxBObMmYNHHnkktHeWiCLOK78dkXsIRCSm6NydoiC9t6EIy/acwoOLd9ld3qg1YNLbW/DG6gI3t3QWTsEjf8kZ1ghnduEym/cQqf5cYgTtwv+R5JtxTOPDT0REXrBSVgjF2VTHqqjXyDgS15JchLKaWytluQpsCRQKBXp2TMbRikYAwCAx2hcaQtO+0MRKWUREREREJKKxY8d6PACkUCjw4osv4sUXX3S7TOfOnfH111973M7w4cOxdevWgMdJJLaA2+ZQyGwsqMSpGrbPIYpGDJ+QQKM34tf9ZS6v+2ZnKQpUDShQNeDJiUN8Wp/tc8vXKfRgno/+3NTTeCrUGuwtrQt4HJGkskFj13lEDM//ko/n/3S+z8vH+luQh8Y4FMVi/GlPRER+YKUsmajU4RfKCrRSFmDfwjCY9oU6gwkNGr3dlwiDpO0LWV6UiChaSPFpwcwuERERxSqz2Yznfj6Er3eWyj0UEsnUJbvlHgIRiYxfWcnRg4t34Uyd6wCu3iRucCecPfL5HtHX6XiYwt3rL5RBjaLKBlzyynr8nOc6iOcP24pWS7aXeFzWn/kyMYL74f5ex/nD2MaTU4iIyBuGskKsVydLeOmiPh3lHYgLifHOOw5NrZWyXFXRsiWEsrq2T0Kndkl+b1uolDXzu/245JX1dl8cTZK2L7QQs384ERHJ47aLegEAhvVIC2o9i+7LEmM4RERERGFJbzShpfUELE+2FVVjac5J/OfHgx6XM5rMuH3hdqzKV4k1RCIiIvKFizntncU1bhcPtpqR2Qwcq2hAVYM2uBWFwP7T9aKvc/ne06KvM1grDpSLtq7dJbUB3zaYwytlbkKEkYShnNgU6xXiiIjId2xfGGLfPnIpvt5ZiimX9ZN7KE4SbaphxSksZ340CqEsL5WyzmkNZQ0MoEoWACTY1Hdt0RtxpLzB+rtR0kpZlv8zk0VEFPnuv7QvhmR2wPnnpAe8jj+POgeTLsjEuMHdsLGwCndk9cZ7G4pEHCURERGRvMa+sQln6lqQ/8JEtFO6nhbSGox42McKE/tKa7HnZGAH8X7JO4MrBnVFk9Z7SIyIiNzjcWEKhVM1zbjurS0AgJLXJkuyjcowDnztE7kdolxtR+02a/OzL6F9n9bpwNuxl9wA9yPDCY8vxTY+/kRE5A1DWSHWq1MqnprkW7/2ULOthtVemQC1xoBmoX2hl0pZ4wZ3x9c7S61VSvwV79B0u0Gjt/5slOi7ie2XnjjuNRERRby4OAXGDOgS1DqUrSHkxVMuRoveiNSkBOx6+lqcqmlB1/ZJuPqNTSKMlIiIiEg+QmXq/DI1Lunf2eUyX+8shUbvW4ujYM6jatIZMf3rvYGvgIgoxrH6P0lp+/FqlJxtsv6ed7pOgq3YP4cLVQ1uliOp2T7W5B9378RGk9np2BcRERHFHrYvJKtEm+BVh+REAG3tCxO9hLKG9UzDH7OuwV8u7h3QthMc1t+gMVh/lqp9oe1quVtMRES2FAoFUpMs2fXuHZKR1bcT+nZp59NtkxO5e0VERESRrboxfKtUEBGRM7ZQilFmM+b+fgS/HRSvhZ3gcJka93y80z6k7ePzLBaejpH8mnM39NO1vrcR9Od4ire/VST/Lb35dnep3EOgEODxRSIi8oaVssgqIb5t16F9awsDX9sXBr1tx0pZ2rZKWQaJQlmslEVERFIY078LNh+tknsYREREREREFOU4oxnb1h2pxOFyNQDx2wkeKqsXdX2xxNfXZViEkUR6ExHuit5ogsFotjth0ewlphcOf4ZguataeOiMOsQjoVCRq/0oERFFJpZyIKsku0pZllCWtX2h5KEsD5WyJNq5sct6cQaDiCimZbe2Pbz7kj4el3v9tuG4qE9HpzCxo5tG9BRtbERERERERESeeAs9UHSqbPCtsuVP+85g27FqiUdjw4+no0LBcENUaH0Mr3p9I4bOWYXyeo31qrONuqBX39R6nIooHLGVMBERecNKWWRl26KwfWsoy9f2hcFyqpRlE8oySlUpC7aVsiTZBBERRYgv/zYGtc06dG2v9LjcXy7ujb9c3BsbCyoxdclul8v0SE9GcmK8FMMkIiIiIiIisuJx4Fjnfd78eFUjHluWBwD414Tzgtya+PP0qnoNLnl1Pe6+pA9mXhfc+Dwxm834csdJnJfRAVl9O6FJZ0R6SqJk24sYYj2kCgUatQZrGOtwmdr2qqjHTiyxh1lSIiLyBytlkVWii/aFWoOlZ7xS6kpZ8fY7rbZBLMlCWTarZZKdiCi2xccpvAaybI0b0t3l5cqEOMy6fohf2/6/a8/1a3kiIiIiIiIiIl9U2FQsCpYUIYQNBZWoatDi3fXHWrchzbGA7cfP4tmf83HnRztw84I/MOKFNThd2xzcSoM8pBDIPS2pbkJJdZPNEMLkuIbZjJ/zzri8KmzGKCEeXoptfPiJiMgbhrLIKjkxHgqFpWpUmsNZIonx0u5WeGoDJVX7QtvVslIWERGJ4b27R6FjapJftxkzoLP15xG90sUeEhEREREREUU7VuwgN2yfGsFOsxt8PHnaXUWt/afq8PiyPJTXt3i4rTRKzrYFmfJbqzitOqSSaGvS0OiNGDtvE8bO2wRd68n0wRLz7+3u+RULgaUYuIvkgB+7RETkD7YvJKt2ygTMvn4I4uPiUKm2P4MmSeJKWfFx7tfv65c9f9mGvWLhbA0iIpLG2MHdsKmwCgDQv2s7p+uvG5aBtYcrPK7j6MvXo75Fj67tk9B/9m+SjNPWd3/Pxl8+zJF8O0RERBT9YuFAGxFRuOKcJvlD7hDBzQv+AACPoayI4sMftKiyEa/9fgT/vPZcDO/V0f7mfqbkDp2pt/7cojMiKSFOkpaSAVEoAh5J6dkgK5bJwDHQx/3h2GP7+uXjT0RE3rBSFtl55KqBeOiK/kiMt39qJMXHS7pdT5W4TBKFspq0BgCWKlmO7ROJiIh8dcWgrljxjyuweMponJvRwel6b58wifFxSEqIQ7cOSigUClw2sIs0AyUiIqKoVKBS4x/f7MOJqkbJtnHSproEERGFnzCJZRD5pLja/X6FRE0zROdrCGPqkl1Yd6QSf3r/j4C3ta71RL8pn+22XhZMGEuqFpGBPHgVag1WHiyXYDDSevTLXLvfFW6fEM5/kwOn68QfEMmKAWkiIvKGoSxyyTGklJgg7U5FvIf+gUaJQlnHqyxf/np3TnUKoREREfnjgnPScc2QjIBum9Wnk93vnzw4GkN7pHm9XWZackDbA4B2SmnD1kRERBQ6N7//B37dX2Z3oE5sV7+xCccqGpwub9Ia8PXOUsm2S0REnrE6R2zzJQMTaP5GrqdW2FR+8oUPf6RTNcFXBXtxxWEs3HQcja0nmQfLvqVlYH9vVyGkQNaUX1bvfaEgvLX2KL7bc0rSbQDunwrHK5swe/lBu8tyjp+VfDwkvQh6pyIiojDAJAq55FwpS9qnSoKH9RslOnPjeOtZxAO7tZdk/UREFN2EPPFlA7t6XM7bJHmcQzA5NSkB4wZ387r9Hf+51usyrkwbOxDn90wP6LZEREQUfrQGEwCgtEba1i9bj1U7XfbCr/n4cd8ZSbdLRETeRUp1IXJtT0kN/v7FHpyS+LM83J8nuSdr8eWOyAh7i1EZx9eHo7SmGf9dVRDQNvaU1Hjc8K/7palS5et9k/o5+c76Y3jqhwPSbgRwm8raVVKDb3ZFxnOagsCANBERecFQFrnkGMJKTUqQdHsJHiplSdW+8ERrpawBXdtJsn4iIopue5+9DqsfuwrDenquahXIRF1aSmKgw/Lq35OGSLZuIiIikl+T1oD7P93ptYKVGK1r1h2pDHodREREse72RTlYnV+B//t2n+jrDrTyVDB7CYHuYvz9i1zvCwXoSLna6TL3Leeix+2Lcpwus314VGqNKNtZdagcBqPrB97d3/lwmRpLc06Ksv1AxMDDTxIK95ArERGFF4ayyKVEh/aFGWlKSbfn2C7RluSVsrqzUhYREfmvY2oSBmd28Os2E8/3rcUh54WIiIgoUIu3FWPrsWr858eD3hdudbyqEXN+PoTyet9b7ERUeyEiIqIIcLrWv1Z3vnwS640m6886o9HPEYnD1yC4ScKUgxTtlsWolhUNYwCAoxWN+Gqn64CVuxHe8O5WbDlaJd2giEKEAT8iIvKGoSxyKTHB/qmRkZYs6fY8VcoySlQpi+0LiYgoFGy/mH94/2j5BuJg6uX95B4CERERSaBBa3B7ne1BUaPZjGd+Ooif887glgV/4POck3j0y72hGCIREYmMQdnY5EvYqUHTtl9Q36KXcjguvb6qAJe9tgFnG7XWy9wNW4wqnu64q9bUojNi/ZEKaPTuA2sfbzmBuz6yrzhlbv3Pk5zjZz1eH8zdVbe439/zRoy/84YC52qpx1s7kwBAgyb0zzU5hUs4jkKHn7tEROQPaXvSUcRKjA91KMt9PlCKUJZGb8SZOsuZRwO6sX0hERGFl6y+nSTfxpwbh+Evo3vj+ne2Sr4tIiIikt8XOSV4e90x6++/7i/HN7tK8eWOtsoRh87UyzE0IiIKUCy0X4sl0fJw1jW3BXI+2HQcAPDR1hNeb1fbHPogz7++34+VB8sxYVgGOrdLwk0jeuLyQV3tlnnltyOub+zlsMXTXqqWBhPqmL+2EG/fNQoHTtf5fdtQRElmfrff+nO4Pq9tq8gRBSNMn+JERBRGWCmLXEqyCWXFxynQpV2SpNvz2L5Qgn3j4uommM1Aekqi5PeNiIhiWyCTT6P7dcb/GztQ/MHYUCgU6Npe2vbEREREFD6e/TkfZ5t01t9P1TQHtb7F20qCHBEREYlFwgJDRH4zmEITdvFnvsXdoisPlgMA1hyuwLe7T+HeT3b6vM7fWm8rB5VaAwCok6H6WbSoUGu9L+Qjv56LTPBEBX7uEhGRPyQLZb3yyiu47LLLkJqaio4dOzpdv3//ftx9993o3bs3UlJSMHToULzzzjtOy23atAkXXXQRlEolBg0ahCVLljgts2DBAvTr1w/JyckYM2YMdu3aJcE9ii22lbK6d1AizkN7QalJ0Uu+rXVhO55RRkREkgq0hHn2wC4ij4SIiIiozbaiarfXNWndt/ARFFY0yNIGiYiI2nBWk7yxnVoPVYggHMMK/gzpg01FPi235nBFYINpVdUgXigonPHwi71wfH1QcHiMkYiIvJEslKXT6XDHHXdg2rRpLq/Pzc1F9+7d8eWXXyI/Px9PP/00Zs+ejffff9+6THFxMSZPnoxxpFFWbAAAZ7hJREFU48YhLy8Pjz32GP72t79h9erV1mWWLVuGmTNn4rnnnsPevXsxYsQITJw4EZWVzj2tyXe2laukbl0IeJ7wlaJ9YXFrf/MB3dqLvm4iIiJfrZt5tdvr+BlFREREcvjPjwexZHuJT8tK8X2diIgoVvl7Upe/n8L+LC96xCCCdhleX1WIvFN1Hpfx9lgt212KE9VNTpdXqjX4ZX8Z9EYTnvrhQMBjFII95ghN+Mg9bLH/bozkEBERkScJUq34hRdeAACXla0A4K9//avd7wMGDEBOTg6WL1+OGTNmAAAWLVqE/v3748033wQADB06FNu2bcNbb72FiRMnAgDmz5+Phx9+GFOnTrXeZuXKlVi8eDFmzZolxV2LCbbtCzPSpG9t1KwzuL1OikneqkbLWSg90qUPnBERUWy7PasXVh4sx7AeaQCASednYlW+CgAwqLv74NU5HVPQMTURdc3OFSgGZ3SQZrBEREQU04wmM77eWSr3MIiIyE+RGcsgILhwiL83lTIIozUYoUyIF3WdLTojUpLcr9Of++NvaKbWpuVzIP79v4MuL5/0zlbUNOnw1KTBOFrREPD6g3ks5Q5EhYMnvt8v9xAoijCUR0RE3khWKSsQ9fX16Ny5s/X3nJwcjB8/3m6ZiRMnIicnB4ClGldubq7dMnFxcRg/frx1GVe0Wi3UarXdP7KXaBfKkj641KgNbSjrbOuXqk6pSaKvm4iI6MbhPQAAvTqlYNyQ7lg38yos/3+XAQAW3ncRlv71EuyYfa3X9Yzq3dHpssfHn4efZ1wOABjaGvQKVDtl4BOmQzIZDCMiIpJTflk9PvujOGTbY1cOIqLww/fmyFbdqMUlr673ulyLzohFm4+jqLLR722YQxTZG/zMKizb7T7YvaGgrbNJpY9t+/67qiDocQkMLo4xyPHyqWk9LrGxoDKocNSxygaYzeaA2qaF6jkhcFVVzFslMqkt33tG1PXxvTj2MNxIRET+CJtQ1vbt27Fs2TI88sgj1stUKhUyMjLslsvIyIBarUZLSwuqq6thNBpdLqNSqdxua+7cuUhPT7f+6927t7h3Jgokhrh9YbOn9oUS7N3UNFq+/HRpz1AWERGJb3S/zlj/xNVY8/hVAIBB3TsgOdESgFIoFLj6vG7IDLBaY7+uqdZ13X2Jb/swo/t2AgBceE663eWpSQno3kH6iphEREQkvsnvbsMLvx6WexhERBQGIrWFWaz7dFsxqmwCSu6CHW+vO4rXfi/A+Pmb7S6vb3GurO3Il6fGlqNVuPeTHThV0+x9YQ/cVYcCgGMBBMq2HKsKZjjBCSJk40sFrGBfsrXNery19mhAr/1weLvYdLTS+0JRigGu6GAbbuRjSkRE3vgVypo1axYUCoXHfwUF/p+9cOjQIdx888147rnnMGHCBL9v76/Zs2ejvr7e+u/UqVOSbzPSJCaEtlLWHaN7AXBddcMkQaUs4YyUzu0YyiIiImkM7NYeqUmSdYoGAMT5+K1/0f1ZmHX9ECyecrHTdZcO6CL2sPyWEOfb/ejVKUWyMfRkS2MiIiKveNCfiCi88EBwZPslr8yn5faW1ga8DfuPbtef4w8s3oU/is5i5nd51stOVDcFvM1Yt/90vU/LBbtX9e6GoiDXEBp1LcG1gow2DRr3XWMoMrmqBkdERGTLryOFTzzxBKZMmeJxmQEDBvg1gMOHD+Paa6/FI488gmeeecbuuszMTFRUVNhdVlFRgbS0NKSkpCA+Ph7x8fEul8nMzHS7TaVSCaWSVSE8SbJrXyj932p0v87Y+tQ4dG2vxNA5q+yuk6RSVjNDWUREFH2uG5aBtYcrnC7v2l6JR68e6PI2gU7i+1Miv70ywWOr4g7JCaht9n6Gb78u7XC6tsXn7fojLSURZfUaSdZNREQULVr07qtcExGRfBiZjUxn6uy/37r7lh2qA/7VjW3hmSYP3+FDxdd7XdskfujH27YVCv8rTn27y769Y7iH3bUG5/2+FQfKcOPwnn6t51SNi3mc8L7rktp5okbuIZAIwvzlS0REYcavSlndunXDkCFDPP5LSvI95JKfn49x48bhwQcfxCuvvOJ0fXZ2Ntavt++pvnbtWmRnZwMAkpKSkJWVZbeMyWTC+vXrrctQYBLjQ1spCwB6d05FSlI84h2qZRhFrpRlNputX9QYyiIionA2bewgAMCfRnif8Fr5zyvw/8a6Dl55EugkgqfJw/FDu9v9/tP0ywLbiBdXnttVlPW8duuFoqyHiIiIiIgolFidI7q4PfkpiIfZn6/8kfZsqlBrsbGgEnd/vCOg26844FulMlcCmUuZtdx9e8dA+XPCnL9+2nfG6bIZX++TbHtEkYpVK4mIyBu/Qln+KC0tRV5eHkpLS2E0GpGXl4e8vDw0Nlp6hx86dAjjxo3DhAkTMHPmTKhUKqhUKlRVtfUJf/TRR3HixAk89dRTKCgowAcffIDvvvsOjz/+uHWZmTNn4uOPP8bSpUtx5MgRTJs2DU1NTZg6dapUdy0m2AahQhXKEiQn2D8txQ5lqVsMMLSuk6EsIiIKZ5f074z9cybgnbtGurze9kt/p9TAPtOkOLHrkwcvxqTzLVVLz8toL8EWLK4+r5tk6yYi6XFfnCjy8IxwIiKi0BPreL8/n+OBbvN4VWOAt/RfdaMWU5fsRoGqIaDb7y2tc3udlGEngS8Vw6Xg6/NAqkrl0civgCwDPFGBX4uIiMgffrUv9MecOXOwdOlS6++jRo0CAGzcuBFjx47FDz/8gKqqKnz55Zf48ssvrcv17dsXJSUlAID+/ftj5cqVePzxx/HOO++gV69e+OSTTzBx4kTr8nfeeSeqqqowZ84cqFQqjBw5EqtWrUJGRoZUdy0mdEhue2qkJUv2NHEpOTEeTbq20rhihbKadQb8L/c0Bna3HBxur0yAMiFelHUTERFJJT010e11KYltn2Od2yWhRoKS/e5cMair08TnJf07W4NSb905Enccr8blg7pKNpEX6uA4UaR46Ir++HRbsdzD8CoUBzqIiIiIYgKPDkc1sXabvYZxRNjOtW9uFq0atZzfF6TeslgvWSlbIH6w6bhk627Syd8eU0yNfrT75LdgIiKi2CNZ2mbJkiVYsmSJ2+uff/55PP/8817XM3bsWOzb57kk6owZMzBjxgw/R0ie9O6civfuHoUu7ZNC/uUnOdE+KGUS6YvFexuKsNDmiwTPzCciokhn2/I3OTEe5/dMw80je+LnvMBL8HvTXpmAXU9fizO1LfjEIfTx3d/b2kenJMXj2qG+heQtn/3+nyHaQaTgOHMhFE1e/fOFuGdMn4gIZRERERFRcPhdhryxbdFX2+z5RC7RKnKJtB45eXtthctrz1O1r2CJ3cHE1vHKJsnWLQd1i+9zWuHy3KHgSBmIJCKi6CNZ+0KKfDeN6InLBnYN+XaVidK0L9xeVG33eyeGsoiIglJSUoKHHnoI/fv3R0pKCgYOHIjnnnsOOl3oqjWRPYVCgXfuGiXpNpIS4pCalOAUog5GWnIibrgwU7T1BeLRqwfKun2iaPT/xvJ1RRRqb6wuwK/7pQlnbz9+Fvd+slOSdRMRUXDMURGDIXd2nKgJ+LabCqusP685XOFx2XCsZKs3mmTZ7qma6G3dxzCJvPxqdUgRIQzfOomIKMwwlEVhJ9mhpaBYoazMdPsWR10YyiIiCkpBQQFMJhM+/PBD5Ofn46233sKiRYvwn//8R+6hxbxfZ1zh87KBzhs4tlUc1iMtwDVZxPk5g6FQBHb27f45E/CPawY5XX7LqHOw5clxAayRiNx5atIQuYdAFLWa3bR8WbDxOMrrNZJsc+3hCuSdqpNk3UREFJhKtRYAcKZOmvd+Ci25D+yHW66gqLIRo19ehxadMeTbfmXlYY/Xf7qtGDknzoZoNOKSsACWz842aeUegmzkfp2TOMLgZURERBGEoSwKOylJDqEskc7ccGxXyPaFRETBmTRpEj777DNMmDABAwYMwJ/+9Cf861//wvLly+UeWsy7sFe6z8uKNRl0+aAuHq4V57P8nI4p1p8zOiR7WNI9xzCZrT5dUq0/jx3cDQefnxDQNkLlxuE95B5CREsTqf1luJlwvm9tQ4koss1eflDuIRARURhQqS1hrGd/OiTzSIjaiJk5qW/RY1dJ4JXCAiXWMQly7WhFo9xDkA1DWdGH1c+IiMgbhrIo7CQ7tS8UZ70avf2KWCmLiEh89fX16Ny5s9zDiBmeWgtcf4Fv7QDDYZ6xUzv3QSlbfxrZU5Tt3XVJH7vfu6e5Dnh1SPZtXHJ5/fbhWHjvRXIPg8JM1/ZKuYdg55/Xnit7e1KiaKM1GPFznjQtComIiCh2iRUWadS6rugZjKMVDThSrsaSP4pFX7crUs+VhLqFoMmmPBbbncqLAZ7oEA7zqUREFDmi8/RwimiO7QtNItXTbXL4MtiJoSwiIlEVFRXhvffew7x58zwup9VqodW2lSlXq9VSDy0mvXHHCHRtr8TtWb38ul2P9GSU12vw0/TLccuCP5yudzdx6CkgZmvs4G7YVFhld9mEYZnILa31elvbTQQyWXz3Jb0B2FfcAoCx53Xzf2VhIimB51jIacKwDKw5XCH3MMLazOvOAwD0m7VS5pEQRY9/fX/Ar+U3FlbiV4a4iIiIwp7cFXTECou8vPKIKOsRNGoMmLB4i6jrjCVzfj6E3w6WY83jV7N7iEQqG3xvxyhH5TeSltzv3UREFP54FIfCTnKiNO0Lmx16z/MLCBGRa7NmzYJCofD4r6CgwO42Z86cwaRJk3DHHXfg4Ycf9rj+uXPnIj093fqvd+/eUt6dqHNu9w4+LddemYCXbrkAI3p39Gv9m58chwPPT8BIL7dTihgGivN18iLIXYJ7Lunr8nJXgbJImU/p37Wd3EOIWM/cOCzodcy+YagIIyEi8p3RZMav+/0LWE39bDeW7zsj0YiIiIhICqVnm3HgdJ3Py4txYnO4BgsqGzRyDyGifZ5zEtWNOny546TcQ4laWoPR+0KtdAaRWsOQvFgpi4iI/MBKWRR2lA7tC00mM/aU1KBFb8SV5wZeycKxbDLbFxIRufbEE09gypQpHpcZMGCA9eeysjKMGzcOl112GT766COv6589ezZmzpxp/V2tVjOY5YPVj12FsroWDOuZJup6HecQkhLiPFZfEgJMyoR43HrROVi+V76DvP7OF1/YK12SccjFbPa9QhlZfPrgaFzcvzO0ehO6dVDiqR/8qzbjKJ5/fyIKsSPlrDBKREQUrTT6trDGVW9sBABs+/c4n2779E8HMffW4ZKMKxYxb0H+8KdSFkUH2zagnBkiIiJvGMqisONYKUtvMmHqZ7uhMRixb84EtFcG9rRt1tmHslgpi4jItW7duqFbN99CsGfOnMG4ceOQlZWFzz77DHFx3qsnKZVKKJXKYIcZcwZndsDgTN+qZAXK33zJmP6dZQ1lxapL+ndGalI8UpPivS9Mdq4dmmH5IVnecRAR+epwmRoHz9ThL6N7Q6FQ4JmfDsk9JCIiIpJIlYtgx7HKRp9u+82uU0GHssL1pJ/wHFVwGPqKLifPNss9BJJRuL53EhFR+GD7Qgo7yQn2Bxi1ehMatAbojWY0aPQBr7dJa19Ctks7BgKIiIJx5swZjB07Fn369MG8efNQVVUFlUoFlUol99Bihtxf+Yf2aKvalZbsKTQtzUg9TWLeO6aPJNsMB8seuRRLpl4SNZM+90TwY2UO46n0C8+JrspwRNHKZDLjRFUjzGbX7yc3vLsV//7fQfx+iPtXREREJC2t3ogzdS1yDyM8SPxVb19pnbQb8MDNbicR+YGvIyIi8gdDWRR2klvbFybGWw40avRtYSqtPvB+202tlbJuuDATd2T1Qu/OKUGMkoiI1q5di6KiIqxfvx69evVCjx49rP8ocgQT6xneqyNuHN4D/bqk4q9X9PewpOeS3gO7tw9iFK698ucLPV4/SIJthkq0hLEEkXpvsvp2Qu9OqXIPw62vHx4j2bqH9RC3jSpRLHvul3xc8+ZmLNx8HGazGYfL1HbfgQX5ZfUyjI6IiIhiyYnqJlz+2gYcq2jwuqyr/RWpPP/r4ZBtK5ot230KAKt0EYktUue1iIgodBjKorAjtC8UKmZpDG1BLK0hiFCW1hLKembyMLxxx4ioO6BJRBRqU6ZMgdlsdvmPIsddl/T2a3nHx/f9ey7CpifHITXJ//bCd1/SG6/deiGuGNTV51nBV/58AZIT4/Du3aP83p6tTqmJQd0+Wozq01HS9Z/fM3rDOz88mo24OP/2J5MS3H/9GpwhbnvSDsnSPcevHdpdsnUTxZovdpwEAMxbXYhf9pfhhne34u6Pdzgtt2DjcTzL1oVERESiioj5CxmGuPZIBZbmnPS4zLA5q0I0GnmEc1XkQAlV0CLhaU8U7vgyIiIifzCURWFHqJSVnGQJZelsgli6AENZOoMJeqNlN6ldAAeNiYiIolX3Dm3tfEM9MTeyd0fcdUkf34PSCuDeMX2R/8IkXNyvs6RjE8Z0XkbkVdR6/bbhPi8b58PffnwQARxlQhxKXpuMktcmB7wOW8/dNAxd24dHC+pAAv73XOK+VWO0nC/Qt0v4Vg8jCnff7CoF4L6djRDgIiIiouDlnqxF1svrsHzvabmHYiccgmKFKu+VskzyD1NSYfAwSCiq7xxRyEXLfA4REUmHoSwKO9ZKWYnOT0+tIbCyyM2trQsBIFUZH9jAiIiIYoxtYEsgZ6VJYR8h3kt1IjGrP718i+c2iHLr09k5ANOnSyp+eDRbtG14qu4UalMv749nJg+Vexh2IjmEdPmgLqJPHnIukigwZgAnqpq8LnekXO3Xeuub9QGOiIiIKLr9/Ytc1DTpMPO7/XIPxc6mwir7C2TYwQ5la8JwFc0hi+gOnBGFRjgEaImIKHKEzxEWolbn90xDfJwCw3t1dLou0PaFja2tC5MS4pAYz6c9ERFFhzEDLNWiOkZxK74u7ZKsP3dM8e1+fvzAaNG2n5bivcLmsB6+t+hb/v8uC2Y4TuLjFBjYrZ2o6wy1Wy86x6/lw21y3HE4C++9CDPGDXK57Lgh4dX2r2NqEo68OAnTxg6UeyhEMam8vsXud18OgPr7nbiqUePX8kREBGzZsgU33XQTevbsCYVCgZ9++snuerPZjDlz5qBHjx5ISUnB+PHjcezYMXkGSwEzeTig3qQ1iHLAXWswolLt32fxmsMV9hfIcNyfWQP+DYjId3KewEpERJGB6RQKO1l9OyNvznV4csJgp+sCr5RluV17JVsXEhFR9OjeIRm5z4zHjtnXirK+UMwhXGMTSvE2aVHw0iTs+I/7+5bgpmKWL+3tFCKebvzLjMt9XvaiPp0C2sYXD10CwPV9dtWC8LzMDgFtxxUFFPj+0WxcdV43n5Z/4U/nt93Wy2O89alxyOorbStKwTkdUwK+bWK878+XK87tinM6ud7W+T19D/CFilCBzh/KMKqeRhTJXvz1sN3vUkzmj5+/RfR1EhFFu6amJowYMQILFixwef3rr7+Od999F4sWLcLOnTvRrl07TJw4ERoNg7CRxF3o6lhFA85/bjVmfLMv6G1c/85WXPLqehyr8N4OULCxoNLu97NNOp9v+08Rxgx4DqzFCmYs3Pu2teU2USzjuyQREfmDs+kUljokJ7psTaTVB1cpKzWJrQuJiCi6dGmvDChUIZdO7ZIw9fJ+GJLZAX8a0dN6udlhOuPPo85BcmK8x+hU9oAuEo2yjTLB+982IQRVOK88txsKXpqEoldvcLpu6uX9nS5LSxa3etrF/Trj4weyfFr2vAzfAmF3X9IHvV20X5TKxn+NDfi23Tsk+7ysp1CFq2Mb947pE9TYghLgLOKDl/XD8F7p4o4lxjz//PNQKBR2/4YMGWK9XqPRYPr06ejSpQvat2+P2267DRUV9lUTSktLMXnyZKSmpqJ79+548sknYTAYHDdFMqlt0qFJ6/nxaNC0XW82A/UtbDVIRBQOrr/+erz88sv485//7HSd2WzG22+/jWeeeQY333wzhg8fjs8//xxlZWVOFbUofJnNZtS6afG7+I8SAMDKA+VBb0doTfz7IZXvY3PYSV++97TPt/1lf5nPy3oinOAcy/RGM+qafQ/ExZJZyw/KPQQiIiKiiMJQFoUtV6EsnTGwUFazlpWyiIiIXMlMd189SKozQ5+76XyseuyqoMNkwYShHCe63enftR2mXNYPj40/N+BticXd3+vuS3qHeCS+89TyY8L5GSEciaWNdaA8VYZKT01ye50v5tw0DP27hncLyl1P21es65CciF9mXIFjr1yPfl3sg3XB/J1jzfnnn4/y8nLrv23btlmve/zxx/Hrr7/i+++/x+bNm1FWVoZbb73Ver3RaMTkyZOh0+mwfft2LF26FEuWLMGcOXPkuCvkoEGjx6iX1uL851bLPRQiIhJZcXExVCoVxo8fb70sPT0dY8aMQU5OjtvbabVaqNVqu38kn9X57kNSJpPZ6fcKP1sQOjpwuh5VDVrsKanxuqzYJ9gEgoWyLN5cc1TuIUjCn+prROQa3yeJiMgfnDGnsCVmpawmHStlERERuWIbWPaUwXr2xmEAgDf/MsLvbfTqFHg1pHCY43j+T+fjsfHnIT1F/slxVxwrM/nSvlHwLxftokMlq29grRzlmPjyFFB8+86R6N6h7W/uKYjmaxjQ2zbF0qW990CZQuG+UlhifBw2PTkO11+Qab0sVO0oo0FCQgIyMzOt/7p27QoAqK+vx6effor58+fjmmuuQVZWFj777DNs374dO3bsAACsWbMGhw8fxpdffomRI0fi+uuvx0svvYQFCxZAp+NBFrkdrWiUewhERCQRlcoS5snIsD/BICMjw3qdK3PnzkV6err1X+/e4XtiRSz4Oc99RSmDQyjr0S9zMebV9dhYWOnmFt6tO1KBi19Zh9sX5WD78WqPy/75onMC3o5YjlX63m4xmtVEYaWsfaW1cg+BKCoI8ztsdUpERL5gKIvCVpyLvRmtIbDSyULbiHaslEVERBSQh67oj6MvX49xg7v7fdvkxHhcNywDGWlKjB8a2upIgYq0OZV/Txpi/f+g7u19vl32wC449MLEoLZ97RD754S3CanJF/ZA/gsTw+IMcF95ilL179oOP06/XPRtZvjRMtHVyQy+8OVW/obgOCHpu2PHjqFnz54YMGAA7r33XpSWlgIAcnNzodfr7SpwDBkyBH369LFW4MjJycGFF15od0B44sSJUKvVyM/Pd7tNVukIL6ogq24QEQVKrWG71FCbPXs26uvrrf9OnTol95Bimtbg/sRfo8n+ujWHLS2kP9l6wut6F20+jtnLD3o8UWPbMc+hrEq11u737cfPet2u2Koboy+MFAgFAI0+ulo5ltY0yz2EmMfvzNGFDycREfmCoSwKWy4rZXn4wuxJk87y5aldEkNZREREgQqmLdnHD4xGzqxrg2pZ6FgRKlK9+ucLRV/ntLEDUfLaZEwbO9Dv23pt7+zlz/7WXSPx8JX9fd5eQrwidoPyLo7NKIKcwrtzdG/cFoKz6Qd0C+8Wi5FmzJgxWLJkCVatWoWFCxeiuLgYV155JRoaGqBSqZCUlISOHTva3ca2AodKpXJZoUO4zh1W6QgNXz6uPs8pQVGl+4pai7cVo7H15CIiIrHpA5xfIyAz01IhtKKiwu7yiooK63WuKJVKpKWl2f0j+XgKTRmDqMz72u8F+GZXKfJO1QW8jiXbSwIfAIlqxYFyDHl2ldzDoCjjqhgBRaBwKO1PREQRg6EsClvxLitlBRjKap3MTlWyfSEREZFc4gKs5hNt7hnTx+XlXdp5byUntVF9OgZ0u0idVEyQ6Dk5OLODJOt15b+3D0d8nPRf6zLT3FfuurgfWxb66/rrr8cdd9yB4cOHY+LEifjtt99QV1eH7777TtLtskpH6FWoNTCZnGfs5/zsvqIZALy44jBe+vWwVMMiIqIA9e/fH5mZmVi/fr31MrVajZ07dyI7O1vGkZE/PJ3w4+pzG/DvZAqNPjKCj9WNWizafFzuYRDFFE6NRZdoOYGUiIikxVAWha34ePFCWc2toSyvlSCIiIhIFt0dWrVd0j/6Qh4L7rnI4/X/vPZc/HvSEPwkQSs8W+MGdwNgqV7myNNUkq8HIWxPOpd7ckqo4DX7+iEur//71QMk2e5FfTph0X1ZQa1D7D9dh+QEnNMxxWEblo1c3K9TUOvu0l7+QGGk69ixI8477zwUFRUhMzMTOp0OdXV1dsvYVuDIzMx0WaFDuM4dVukIvTGvrseDn+0K6Lbbijy3NyIiImk0NjYiLy8PeXl5AIDi4mLk5eWhtLQUCoUCjz32GF5++WX88ssvOHjwIB544AH07NkTt9xyi6zjJnGYbcqfrM5vq0Dqz/65p2V9Ka6iC1E1u2lf5uK13wtCsi0KD4EeXyHxBFstm8IDC2UREZE/GMqisOW6UlZgPdwbtZbbpbJ9IRERkZPHxp8LAHjFoa3eo1dbWuFNvrCH5GN4/LrzMPnCHphz4zC8fedI/GV09LXUctWa2VZKYjymjR2IQd3bSzqOhfdlIW/OdbhuWIb3hW0kJcT51aYwHPz1iv7Y++x1+PvVrts6JsZL93Vo0gXugzG+uCOrl0gjsch95jpsfnIsJrh43McN7m59vQfL3bO8QzL3wz1pbGzE8ePH0aNHD2RlZSExMdGuAkdhYSFKS0utFTiys7Nx8OBBVFZWWpdZu3Yt0tLSMGzYsJCPPxZ9tfMkfs474/I6x9fB1mOBhas8tVYiIiLp7NmzB6NGjcKoUaMAADNnzsSoUaMwZ84cAMBTTz2Ff/zjH3jkkUdw8cUXo7GxEatWrUJysvvKohQazToD/v3DAWwqrPS4nK+fsX//Itf6s1gnnPiy6Y+2hKZ61e6S2pBsh8LHUz8ckHsIxExWVOHDSUREvmAoi8KWqy4s2gBLPzfrhEpZbF9IRETk6LHx52Hvs9fh7kvs2+pNuawf1jx+Fd65a6TkY0hPScSCey/CX6/oj1tGneM1wCQ1ZWL07iYrFEDHVN8rG/318rYg1tOTAw97XHWepULXA9l9A14HAFw2qItfy3cWoS2kWM9Gf+IV08YO8nlZX7JlSQlxSIiPw9suXs8KhQLjh3b3ePtgsyH/m3YZbhrRM7iVRJF//etf2Lx5M0pKSrB9+3b8+c9/Rnx8PO6++26kp6fjoYcewsyZM7Fx40bk5uZi6tSpyM7OxqWXXgoAmDBhAoYNG4b7778f+/fvx+rVq/HMM89g+vTpUCqVMt+76Fde34KnfzyE//s2z6/g1K7iGjz940E0tlZy9qasXhPoEImIPGLk07OxY8fCbDY7/VuyZAkAy77Tiy++CJVKBY1Gg3Xr1uG8886Td9BRztfP24WbjmPZnlOY8tnuILbl+nJ/vhN4WvaXvDPWuWp3dpyo8WNrRBRJ2L4wOvD8GSIi8kf0Hm2iiOeqUpbOGFgoq0nHSllERESeuAquKBQKnJfRAQkSVhOSi7tqVK/++UKcl9HeZfgokBOjbUMow3p4bhMWJ/LM3Py/jMCMcc7BHlf7WK68e/co5M25Dll9Pbe283XUS6ZcjD3PjEdW3+BaUzq2uhRLZpr0lQ08Tdo5XucumJiS6HySwT+vORfndEzBE9d5Pxgo1/7weRkd8N7do2TZdjg6ffo07r77bgwePBh/+ctf0KVLF+zYsQPdulnCi2+99RZuvPFG3HbbbbjqqquQmZmJ5cuXW28fHx+PFStWID4+HtnZ2bjvvvvwwAMP4MUXX5TrLsWUBk3bgdRbPtgOk8n+BeyqkobZbMZfPszBVztLcceiHMnHSEREFC30RhNueHcbZny91+uyZ+paJBuHf+0L3S9cVq/BI5/nur0eAIwm918cvthx0veBEFHYYfvC6CJSEUUiIopyTKhQ2HJ1ICrQSllNWqFSFp/yRERE0Uih8O8stVnXD0VSfBxuHnWO3eX3jOmDe8b0cXMr3yTEKWAwmXFHVi/cM6YPft1fBgDo0yXV6+3EdOtFlvZ3728sst+Oh5DdmAFdsLe0DgAwYVgGkl0EgAIVF6dA1/ahreDjbbLT9voeHZOhUgdWlcb2zH2x2pr4o3taMrb9e1xQ205PSRRlLF1EqEwWC7799luP1ycnJ2PBggVYsGCB22X69u2L3377TeyhkQdzfj6EoxUNmHPj+dbL9p+qg0qtQc+OKR5va/sZdaRcLdUQiYiIos7u4hocKVfjSLka798j/fZMbr5YutvT/uyPYlQ1aPHUpCFty3rZLd9W5Lm1cZOHSlrP/nTI88qJKKwxxBMdzKw7SkREfmBChcKWQqFwOsCqNRgDWpcQykpl+0IiIqKIkhCnQPcOSjRqDTjHywFvf6SnJOKFmy8QbX221s68GisPlOHBy/qhqLLR79u3Swr9/srGf43FhoJK3DumD/7f2IEwmswBB7KicYLR0u6xSZJ1izWR5ymQ5UsY7tyMDqKM4+9XD8SxykbccGEPUdZHFE4+z7FUpsg5cdbucseXn6tXI6fsiYiIAuPPZ6gYFWhW51e4Xreb/e0Xfj0MALj1orYTfoIdxYHT9UGugYjCVRROmcQ0Vj4jIiJfMJRFYS0hTgG9se2rt9YQaPtCSyirHdsXEhERRRSFQoE/Zl0Dk9mMpAR52yj6Womrf9d2mHHNuZbbBLAdhUKBB7L7Wg/+h0L/ru3w0BX9AUDU6ljhPjVle1zFU6WoSednIvdkraRjOadTCgorGiTdRii0UyZg4X1Zcg+DSFJGk//fS4urpQl2EhERUWh4K2zcpG07mdiXE1XONmqDHBERRSI5qmuT+Pyp1k9ERCTvkS0iL+IcdlADDWU1t34pbsf2hURERBEnMT4OyoTYqnb5wp/Ox5MTB8s9DN85zCm+ePP56NZBibm3XhjQ6hbcc5EIg/Jehcr2wEr/ru3cLydSa0lP4+mRnuz3+pQyBxWDkZwYuWMn8jYB7+o4y/j5m6UZDBFRAHggkSJJ+MQX2kay88RZPPPTQTRo9G6XNXt5oTm2mSei2MBMVpTh40lERD7gTDiFtXiHA2C6ANsXNgrtC2VoB0RERETkL4VCgU6pSXIPw6W1j1/ldZkHsvth13+uDbgl3uTh/re+mz5uYEDbEmT17YT9z03A/jkTXF4vVvvM8UO7+7RctE7UfvPwpRjWIw3fPHyp3EMh8ounA6tsWUFERBRZgs0l3vnRDny5oxSzlx90vw0vG/l1f1mQoyCiSMRvDtGB+XYiIvIHQ1kU1uJFqJRlMplR06QDAHRpH54HN4mIiCg40Xi2v7cqT3JxGbRyMVQpS/J/dH+WU0iqSztlUOvM6tsJ6SmJSE91bmOoADAkM7CAmaOXbrlAlPX4I5wCXtkDu+C3/7sSo/p0knsoRH7ZVlRt/dnbuzNDWkRERNHH1T71igPlLq9XKLzvL6g1BnEGRkQRhe0Lo4Nw0g4fTSIi8gVDWRTWHFvFaPX2oSxvZaABoK5FD4PJslywB+uIiIiI/BFukzOXDugs9xBEMeH8TPwx6xq7yzq38z98789k6Gu3DUd7H1ph+7J/GqxbRvYEAEwbG1x1MCKyt+SPYry5ptDldV/tKA3xaIiIiAiAX1+qpMw6CNPU5fUtLq832XwNUAAwefleEG7fFYkoNJjJii58PImIyBcMZVFYS3AMZdm0L9Tojbj2zc149Itcj+uoatACADqlJiIpgU95IiIikt+I3h1l2e6H942WfBtyVS27aURP3HVxbzx/0zBJ1t+tgxIv3XK+y+t8DXcFEhwTpCVbAmFZfTvhjTtGYMU/rsA/rzk34PURkbPnfz2M9zYUoaiywe7yT7aewKp8lfV3x/c527cAs9mMkzVNUg6TiIgo5r2+qgCfbisO+PaOe+9rD1d4PblCqIR58myz13XOXn7Q6/ciHsgnik186UeHaKzYT0RE0mFChcKaY6UsnbGtUtaRcjVOVDdhVb4KTVr35Z6rGy2hrG4dWCWLiIgoWoViQtt2G6lJ8UGt6+P7s4IcTWBcteYLVriU3o+PU+C124bjz6N6yT0UJ4+NPxf7nr0OyoR4p7ZmntqcXdLfUtns4n6d8MuMKzBt7EC8fddIJMbH4YJz0p32ld0RY7IwXNtpEkmhrlmP+mY9AKCyQYOXVx7xuLztK3HxHyWY8fU+CUdHRBQ8fq5TJCuqbMAHm47jpRWHA16HxqEbw8Of78H6I5Ueb+Pta09+mdr6c4GqAS06o4eliShWxYXJHAqJg63riYjIFwxlUViLV7hvXxhvcxCqsML+TGZbQqWsru0ZyiIiIqLwkJYifjiKnMk9OTamNVR19yV90Km1SpbSTeXW+7P7Ol226L4sPHfTMHx4/2j069oO/540hPu0RCFw+6IcjHhxDSobNGjWOh9Q9RRmmLfadftDIiIiEkeTi89mga97/zknzjpdtvtkjcfbeMtR/OfHgz5u3cIxGEZEsSFcTmwjIiKi0EmQewBEnsQ7tS9s+7Jqe7ZRoaoBF/Xp5HIdQiiLlbKIiIgoXCQnxuP+S/uiRW/ED7mn5R6OqEI5vziwWzscr2pCr04pIdmeu4pT7lqdfPPwpdAYjEhNavvalRDv+g80JDMNP02/HLcs+MN6Wed2SZh6ef/ABxwifTqnyj0EIklsLzqL3SWeD9ACQLPOiMnvbkXndklo0bMqBhERkVi2HK3Csj2n7C5zteddqGqAyWzGzmLvn9vu/C/3NG68sKfb64UTPsrrW3xbIXMXRERRjxk7IiLyBUNZFNbiHAoJaA1tE9wam4BWoer/t3fn8VGVd///37NkJgkhC4QkhIQl7FvYicENSxQUq6i1uNQiKhaV2wWrglWR3rVwi7VWpdq7fpX2197uVVtBqmVxQVxAwiKLIiCohD0JS8g21++PkCGTTJJJMmvyej4eeTCcuc45n7nmzHxmznzOdTUwUlb19IWMKgAAAPzEH9PB/fekQZIU8KKsH/VL0fKt+91T4QVEiE5CLZo6Wv/vo526IcCFS03pu5pXvVqtFo+CLElqHx2lSUPT9Wb+D5I8R9xpHx2ZX8+GdU3So1dkq1tHirPQunx35IT+/unuRtu9tvY7jymLAACAf/z8+c8abVNW4dL4Jz5o8b4OHivTj5/+qP4GFulkeaXuenl9i/cFoO2yUsTTKvjjvCAAoO2IzLP+aDPqTF9Y4ZIxRhaLxWOkrK0F9Z8AP8hIWQAAtHo9kttpx4HjoQ7Dr4ZmJvplO7+fPFSLN+zVRYPT/LK9cJLZIVYPXzLQ79sd2S1Ja749Ikl687YzNahLgl+3f9f5fdxFWTVF8km9n47KDHUIgN8dPVnhdXnt12pZJdMPAYgsoZ7iGWiJ2kdvsEapfG/zPt30lzVB2VcwjPvdylCHALRJibFRoQ4BfsQnKgCAL6yNN2meRx55RGPGjFFsbKwSExMbbHvo0CFlZGTIYrGosLDQ476VK1dq+PDhcjqd6tWrlxYtWlRn/YULF6p79+6Kjo5WTk6OPvus8StoEBlqT19ojFThqjoDfrLcc/rC+qaNqR4pK5mRsgAAaLVmTeina3K66tXpuQHbR82PGsEYnnxgeoJem56rj+47r0XbSYiJ0jU5XZUY6/BTZK3/ys6Lszu7b/urOK6pWnkXAwCAEDJeJ4ADIkOdozdIh3NZhUsfbT/oc/uKMC/a/qaVXdQERIpB6f696AuhwWcpAEBTBKwoq6ysTFdeeaVuueWWRtveeOONys7OrrN8586dmjhxos477zzl5+frzjvv1E033aR///vf7jYvv/yyZs6cqTlz5uiLL77QkCFDNH78eO3fv9+vjwehUbsoS6oaLUvyLMo6cqJc+0+NiFXbAUbKAgCg1YuPidJvLxusUd1PTzPXOSE6aPu/enTVKEG3ndfTr9sd2b2DMpLCb0q4s3t3CnUIrVKgiv2CUUQItEZ/+mCH1+VPLf86yJEAAIBIs+H7olCHACAc8f28VbFwwgUA4IOAFWXNnTtXd911lwYPHtxgu2eeeUaFhYX65S9/Wee+Z599Vj169NDvfvc79e/fXzNmzNBPfvIT/f73v3e3efzxxzVt2jRNnTpVAwYM0LPPPqvY2Fg9//zzfn9MCD6rlw80paeKsWoPTb214KjXbVCUBQBA2/TWbWcGbV+/mTRYi28/S3ef39djeUp88ArDgikmyua+7Y/TT4umjvLDVlom3KYODJdwzutLAR5Q28lyz5EvOA0PAID//c/SrV6XV7o88zCjlQCIJEwh3HKLFy9WTk6OYmJilJSUpEmTJgU9hnA7hwQACG8BK8ryxebNm/XrX/9af/3rX2W11g1l9erVysvL81g2fvx4rV69WlLVaFxr1671aGO1WpWXl+dug8jW8EhZnl/Adx+qO+RyRaVLh0+USaIoCwCAtiYlPlrZGf4bFr6hi99sVosGpifIWuuzS5fEGD37sxF6cdoZfoujNRrbN6XOsppTCDYJ5zf96veTh4Y6BCDsVbg4Iw8AgL89s/Ibr8tf+fy7IEfSTHw8AOCFl5+80ASvv/66rrvuOk2dOlXr16/XqlWrdM0114QsHp5OAIAv7KHacWlpqa6++motWLBAXbt21Y4ddacFKCgoUGpqqsey1NRUFRcXq6SkREeOHFFlZaXXNlu3er+SpnrfpaWnp7orLi5u4aNBoHgryio7VZRVe6SsopLyOm0PHy+TMVUfdJNiHYEJEgAAhFx6QkyoQ6jXhEFpoQ7B7+pcjR6AHxzaR0c1a72EmCiNH5iq8kqj1Hj/FuVXT4/ZVk6iJsZGKfHUZ+heKXH6ZMfhEEcEhKf/99HOUIcAAECrsH5PoXYePK5Jw7p4vb+i0qUfiko8loXraCWucA0MQEh5mx0GvqmoqNAdd9yhBQsW6MYbb3QvHzBgQNBj4R0eANAUTSrKmjVrlv7nf/6nwTZbtmxRv379Gt3W7Nmz1b9/f/3sZz9rSgh+MW/ePM2dOzfo+0XTeSvK+nr/MTnsVvc0htWKT1bUabv/1NSFHeOcXrcFAAAi2+u3jNHh42Xq2jE21KG0WbXPJ6aFwZSNf7puZEC2m9khVh/ee54SYptXMBbJ7p3QTzaLRZcM9f4DGRBujDE6XlapOGfIrkUDgPDFL4kIU5cuXCVJmvuvL73ef/BYmSw1voC4XOE7eeGNf1kT6hAAhCFqsprviy++0Pfffy+r1aphw4apoKBAQ4cO1YIFCzRo0KCgxmKqC295PgEAPmjS9IV33323tmzZ0uBfVlaWT9tavny5Xn31Vdntdtntdo0bN06SlJycrDlz5kiS0tLStG/fPo/19u3bp/j4eMXExCg5OVk2m81rm7S0+kckmD17toqKitx/e/bsaUo3IIhsXj6hTvvrGo2Zv1zHy6qKsKprrYq9jJR14FhVUVanOKYuBACgNRrRLUnnD0it9/5ouy0g+01PDN+RuUKte3K7UIfQYucPrPou0Sslrs59mR1iFd/MUbwiWXx0lOZeOkgjuiWFOhTAJ7e/lK9Bc/6tTd8XhToUAADQREdO1D3P683a3UcCHAkA+JeVwQOarXrGpYcfflgPPPCA3n77bSUlJWns2LE6fLj+kb1LS0tVXFzs8ecvPJsAAF806ZLRTp06qVOnTn7Z8euvv66SktNDDX/++ee64YYb9OGHH6pnz56SpNzcXC1ZssRjvffee0+5ubmSJIfDoREjRmjZsmWaNGmSJMnlcmnZsmWaMWNGvft2Op1yOinSiQQNfUA9fLxMkpQaH629RSe9T194rKpNxzimLgQAoC2af8Vg3fTXNbp1bC+/bvfH2ekqrajUqB4d/LrdiNXKzkJ1SYxR/kPnq52PI+zUnGoxytb8zmCGE8B//rX+B0nS8x/t1OOTh9bbrvhkueIcdn4cAQAgApVXuOq/r9Kltzf8oDOyOqpzGE93D6Bt4WtHXb7O0uRyVb3n/+pXv9IVV1whSXrhhReUkZGhV199Vb/4xS+8rhuI2ZM4fQMAaIqAjeO/e/duHT58WLt371ZlZaXy8/MlSb169VJcXJy78KrawYMHJUn9+/dXYmKiJGn69Ol6+umnde+99+qGG27Q8uXL9corr2jx4sXu9WbOnKkpU6Zo5MiRGj16tJ544gkdP35cU6dODdRDQxDVHCnLYbeqrMYX7YNHqwquUk4VZRWfrFuUday0ajSt9tFMWQEAQFuU1SlOy+8e6/ftntW7o0Z0oyArkOJjQvv5LTHW96L+hJgovTB1lKKsVjkDNDpbMFyT01X5uwtlJG3ZW6xLh6SHOiQgoLbvP6q8xz/QOX066a83jA51OAAARLyjJ8sV67DL1sSqA5fL6LsjJY03rL1eA7+KP/fhTv3P0q2Kc9q1ae74Jm8bAAKhb2r7UIcQdu6++25df/31DbbJysrS3r17JUkDBgxwL3c6ncrKytLu3bvrXXf27NmaOXOm+//FxcXKzMxsWdCnWJiPEgDgg4D90vHQQw/pL3/5i/v/w4YNkyStWLFCY8eO9WkbPXr00OLFi3XXXXfpD3/4gzIyMvTcc89p/PjTX6ImT56sAwcO6KGHHnLPH7x06VKlptY/jQ0iR80v8O2ddh2qKHP//+CpqQlT21eNeuZtpKzqoqx2DoqyAACA/7T1gqym/sjSHLeO7aVN3xdp1fZDAd+XP5zXN8XnthlJseqdEqdYp10O2+kZ5QN1Lq/mPhry28sGS5KKTpTro+0HNa6/748JCCeuen6hdbmM1u05on5p8WrntOv/Pt0jSfrgqwPBDA8AgFapoOikzpi3TNkZCfrnjLN8Xu/xd7fphY936YkGRrasZryMTWLqGW72/a/2Szp9fhgAwkF2RmKoQwg7vs7SNGLECDmdTm3btk1nnVWVZ8rLy7Vr1y5169at3vUCMXsSI50DAJoiYJUqixYt0qJFi3xuP3bsWK9foMaOHat169Y1uO6MGTManK4QkavmFBJx0XYdOn66KOtAdVFWfLQkqbik7hfs49VFWT5OPQMAAIDGTT+3p5ZsLAjoPhJiovT3m85Q91mLG28cYWxWi/595zmyWAJ7VeXT1wzT/He26plrRzRpvYTYKE3M7hygqIDAWvvtEV373CenF9R4ib30+R7d/8ZGDe6SoH/9l+8/FgNAa8PviAiEdzZVjWCy4bsir/e/t3mfkuMcGtY1yWP5k8u3S5Iee/erRvdx6FiZvvz+9Pan/22tHry4v9e2n+w47FPcABBMwbjIrbWKj4/X9OnTNWfOHGVmZqpbt25asGCBJOnKK68MSUwMlAUA8AWVKghr9ppFWbUKq46erCq4So2vqnD3Nn1hdVFW7XUBAACa6ry+KXpj3ffqkhgT6lBCrkM736f2g3fWIJyIvTg7XRdnMwUh2pa7Xs7XyXKX1/teXVs1MtbGUz/mcgIdAAD/aWjUkDfWfae7Xl4vSfrDVUN16dAuddr4kpYLT5R7XLR7rLRC972+sdH15v7rS32176juv6i/BqYn+LAnAAgMvoO0zIIFC2S323XdddeppKREOTk5Wr58uZKSkhpf2a8ocQcA+I5KFYQ1q6X+oqxqKe6RssrlchmPH7iOl1VKYqQsAADQcr++dKCyMxJ04SBGEGot2jls7tud2vt3KHsA4eP7whLd+re1Wl9r5I6av4ecLK8MblAAALQyDf08XV2QJUl3vJSv4adGy6oeXUuSNu8t9mEfzfsR/IVVuyRJP312tTbNHd+sbQCAPzhs1lCHENGioqL02GOP6bHHHgt1KJJ8KygGAIBKFYS1mp9P6yusqp6+0GWk42UVah8d5b7v9PSFNq/rAgAA+Kp9dJSmntkj1GHAj2oW80dxYhRoFWpfef6PL75XQdHJOgVZklReeXpErX4PLg10aAAA+F1Ke6f2Hy0NdRiSpA3fFbpvl5RV6q6X83XBwFRdPjyjTtvDx8t07XOf6tipc7fBcrysUi4GNwEQQr1S4kIdAvygodEhAQCojaIshLWa82vX9yU9MSZKDrtVZRUuFZWUexRlVa/TzsGhDgAA4C/pCTHqkxonp92mmCibunaIDXVIAFCvj785VGdZ91mLQxAJAAD+9cTkobrmuU9DHYakqkKras+v2qmlXxZo6ZcFyvTyXeGrfUebVZC1xYfRtBrz7aHjLd4GADSXhfkLWxWeTwCAL6hUQVirnr7QbrXoQD1XfUVH2RQfHaWDx0pVXFIh1Zg6+vRIWRzqAAAA/mK1WrT0jnNksVSdgMpK5kpPf2gfffozK6f1AABAoDC6Q+uxeOPexhv5WfHJcp0orVRaQrTH8g+/Pui+fejY6QKtK59dXWcb97y2oVn7/u2Src1ar6Yf/e79Fm8DANC28VEKANAUVKogrNlPjZQVZbNqf/FJr21iomxKiLFXFWWdLPe470RZpSQpjqIsAAAAv6o59Z/hdJRfpLSP1oKfZCs6yiY70ykCzUJBIwCgLXlt7XdB32f2w+9KktY+kKeOcU6vbVxU/gEA2gC+fwIAfEGlCsJa9Y99DrtV7Rw2HT9VZFVTdJRV8TFVUxYWlXgWZVUPgx3rtAU4UgAAAKDlrhyZGeoQgIjG9BEA0DjeKlsPmzV0T+bmvcU6u3cnr/edKGv61IQAAEQKao8BAE3B5dcIazbL6ZGy/vizERrZLUkXDU7zaBPtsCnhVFFWca2irOrpCxkpCwAAALVxEg0AAACRrNJ1+gNtWYUrYPtxuYwqXUamxgfohj5Lv7Im+CN4AQAQLNUjxlPoDgDwBUVZCGvVV3s5bBYNzUzUa7eMqXMFVkyUTfHR3kfKOl5aNbJWO4qyAABAmHPY+WjuzejuHSRJlw3rEuJIAIQbY4yWb92nPYdPaPMPxaqoDNyP0QAAhKMLB52+eLXEywwD/mCMUdb9S9Tz/iX6+fOfuZfvKz4ZkP0BABA5qMoCADSOShWEterpC6Nq/EhZs8DKZrUoymZVfEzVsuKTp4fGLqtwqezUSfk4B4c6AARSaWmpcnJytH79eq1bt05Dhw4NdUhAxLgzr7fW7S7UBQNSQx1KWPrzlJFauW2/zqd/ANSyYtt+3bBojfv/lw5N55Q4APiA0UJbj7jo0+c8X127RzedneX3fZSUny72+vDrg+7b1RfTlpRVKsZh8/t+AQAIV3yWAgA0BZUqCGt26+npC6u1r1GUFRNV9YXf2/SFJ8pOF2jFOjkxAACBdO+99yo9PV3r168PdShAxLkzr0+oQwhrCTFRunQoo2QBqOuTHYc9/v9W/g/KSm4XomgAAAg+W415k/6/T74NSFFWzSkSa/rfD3Zo5itV5wB+felAv+8XAIBwx/SFAABfMEcKwprVUrcoq+YVYNFRVcurpy+sWZR1rLSqKMtht3qsDwDwr3feeUfvvvuuHnvssVCHAgAA2giXy2jDd4V1lnPBMgCgLameZUCSvj10IiD7cNUzO/DWgqPu2w+99WVA9g0ArckVwzNCHQL8hJGyAABNwUhZCGvVw2A7bKdPMLRz1CzKqhoBK756pKyTVUVZxhgdL60aWjvOyWEOAIGyb98+TZs2TW+++aZiY2N9Wqe0tFSlpaXu/xcXFwcqPAAA0Erd9Nc1dUbKkqSdB4+HIBoAAELDFoQhOir55RkAmuTcPp30/lcHPJYNyUzU7346JEQRIVAYKAsA4AuGD0JYcxdl2WtMXxhdtyirevrCopJyfXvouIbMfVf3vb5BktSOqQsBICCMMbr++us1ffp0jRw50uf15s2bp4SEBPdfZmZmAKMEAACBVOkymvX6Bv1z/Q8B3c8/1/+g7rMWu0fHWr51f0D3BwCtmWFcwVaj5khZTVVUUq7lW/epvLKeobBOefb9b5q9DwBoixZcmV1n2Tm9k0MQCQKFz1IAgKagKAthzdv0he1qjHwVUz1SVvTpoqy3N+xV8ckK5e8prGrvYKQsAGiKWbNmyWKxNPi3detWPfXUUzp69Khmz57dpO3Pnj1bRUVF7r89e/YE6JEAQMOCMLAA0Or932e79dLne3T7i+sCup/q7V/y9Cp1n7U4oPsCACBSWFvwgfba5z7RDYvW6Onl273eX17p0tpvD+t/P9jR7H0AQKj1SY1z3x7QOb7edv/1o15+2d95fTvJ4mX8JE4/tE6cVwIA+IKiLIS16losz6Ks0yNfVRdlpSdGS5J2HTyhdzfv89hGO6YvBIAmufvuu7Vly5YG/7KysrR8+XKtXr1aTqdTdrtdvXpVnbwYOXKkpkyZUu/2nU6n4uPjPf4AIK9/SqhDANAMD765yX27opGRNpqq0mW08bsiv28XAIDWonr2gGoHjpb6vO6m74slSW/mf+/1/ofe2qQrnlnd/OAAhIXR3TvorF7NH6Vp4TXD6yz7eW43/WvGWTqnT6eWhObVRYPTmrXeznkXeV3esZ3Tfft/fz5CV4/O1JNXD6vT7q68Ps3ab20zz+8rZ5SXn16p3mlVmNkXANAUFGUhrNmsVYdozaIsp93mns6w+sNtj+R26tmpncoqXVp/aoSsahRlAUDTdOrUSf369Wvwz+Fw6Mknn9T69euVn5+v/Px8LVmyRJL08ssv65FHHgnxowAQTE57y79WXDiosx8iARBKFS7/npl+/L1t+vHTH6nXr97x63YBAGgtao4AI0m/Wby5yduweZkC0eUyevEzRrUGmmpoZmLY7ccZZdWjP6k7nZ6vJmbX/a5+yZB0Dc5I0K8u6l/nvrvP9724KTsjQSt/OVav3zLGvezdL/c1sIY0aWi61s+5QC9OO0O9U06/B1osFl01KlNDMhN1do2pAmdd2M99OyMpVvMuz9a4fp4XhU09s7usVotS2js91vFWvNWQNQ/kaXBGguKjozTv8sGaf/lgXXdGNyXGRum6M7o1aVuIDN5GRQMAoDaKshDWbKeuHnDYPT/YxJ0qtKoeKctiseiiwd5/yIurMbIWAMB/unbtqkGDBrn/+vSpOunSs2dPZWRkhDg6AME0vGuSJmZ31q1jezZ7G1w0CkSmmj8IlflhRCtT45LjhSu+afH2AABozWoXZryV/0OTt2G3WrTn8An999ubtXDFdpVXunT1nz/xU4RA043u0UG3j+stL/WCkqT/m5ajT+8f5/W+v92YI0lKi4/WmJ4d1c5x+reBpXeercuGdWl0/zed1UMf3HOeT7HOPL+PJtb4XeJvN+W4bw/qEq9PZo/TktvPVv8Gps2rT7eOsdr+yIW6b0I/vXHrGP1+8hD1SY3TG7eO0Zu3nel1ndHdO+icPp20/O5z3cssFovSE2P0yWzvfVatc0J0nWVDMhIkSc9fP9K97L8nDdLI7h0kSX3T2uv2H/XSbyYN0pCMBDntVt12Xi9dMCBVw7smasdvPUevevDiAe7bqfFO/fHa4eqe3E4juiXpwkFpumxYFz1//Sh3m2ln95BUVTz69n+dpX/OOFNPXDVMCTFRyu3ZUX+/KUcXDkrT/53q9/lXZOut287UlSMzJUm9U+I0JDNRM8/vo99eNti93XZOuz6ZPU6f3T9O/5xxph6YWBXXR/f9SF/OHa/p5/bUrvkTdcmQdI/4uyTG6O3/OstjWWJs1YiF907oq+S406NyXT26q64a3VX/PWmQ1j5wvjq1dwoAALRNDCGEsOZt+kKpqijr8PEyRUed/lJ14aDOemr59jrbaOfgMAcAAAgki8XidUoDhKebz8nSq2v2aPq5zS+iA6pNHpWp/FOjFVdUtmykrKKScl3y9EeaMDDN44p2AIB/MeVO6xHlhxFrv9p3TGc/usL9/0qX0ac7D7d4uwiOq0ZlqvBEuZZ+WaCuHWK1+/AJSVJynEMju3XQ7sMnZLWenq6ypkFd4jU0M1F/+2S3e9nXj1yoT3cc1tf7j+o3i7eo0mX0wvWj1LNTnN7bsk8/FJZo0ce7VFlrhNSLBqfpsmEZmvbXNfXGOjG7sxZeM1zdZy12L8vrn6L/bNnv0e6VX+RKqip42vBdoS55epX7vliHTWN6Vo2CtGv+RO06eFxLvyzQO5sKlNOjg87qnaxd8ye62xefLFf2w+/KapH6pcVr8qhMvbHue/f61b7ad1R//+Rb9Uhup+vPrCoE2jnvIs18Zb3eWPe9Fl4zXBcMTNVDb32pFz/brRHdkvTC1FGKj46SMUaTv85Ul6QYxTntyn/ofH2175hGdU+SxWJRWkK0Ls7urC17q56DDu0c+vxXeXph1U79ZvGWevurc0K07Darbjl18dOwrkm6bFj9F0GekdVBL92cW+/9aQnR+vqRC2WM9OcPd2jBv7fpkiHp+uf608Wcj105RIUnytxxxZ+aIvVH/VK19b8n6MDRUmV2iPXY7swL+kqSrs3pKqnq/MD//nykjDGyWCy6dGi6u2B09KliLkn6ZPY4WWpcnfXMz0a4b79+yxh16xir5Dinbh/XW3arVTGOuhffp8RHe6xX7cfZndWtQ6x6nRpJ6/Zxvb32R/U2qjnsVvcsLbU9ePEAXT+me53RBd//5Xn6Ys8Rnd3AFJHeRiRE68AFhgAAX1CtgrCWEOuQJCWd+rda7ZGyJKl/5/bqkdxOOw8eV6zDphNllZKYvhAAgqV79+4eo1sAAMLT/Rf116wJ/WTlxDD8oOZ3tTW7DuuCgWnN3taTy77Wt4dO6E8f7FBuz47+CA8AgFYtPjrK79t8/L2v/L7N1mZ410S9ePMZctisWvvtER06Xqbz+qZo3e4jWrjyG33w1QF327F9O2n7/mP67kiJ/nDVUKXGR+uq//1EqfFOvXvXuUqIidL+oydlkUWjHvlPnX39a8ZZendzgRat2qUrRmSouKRc678r1PVjumvdnkLNvXSgnHabTpZXKjrKpmVb9qlbx1j1SmnvsZ2Pvzmolz7b4y7A2fzr8Yp12FVe6VLftHid2bOjsjpVFbCc1TtZZ/VO1pTc7tp/tNRdvHLjWVXFSg9ePMBd7CRJL0wdpfP6Vk0Ht+O3F6ms0qW/ffKtu7DnzdvO1KD0eNlPXXj9wvWj9F1hia47o5sOHSvViN+cftyLpp4eJUmSsjMStXPeRSooPqmFK7br+jHdPe7vntxO08/tWe8FJ/HRUVr34PlyRlXt+4ysqtGVuie382jXJ7W95l46yGOZxWLR7ycP1e8nD3Uve2TSIN1ybk917Rjr0e6cPp3c/0+MdWh0jw41N6Wbz8nSgaOl+vbQcf328sGyWS266ews5fVP1ee7Duvy4Rl6ZPEWPb9qpyRpXL8Uzb10oNfHVFu/tPa69bxeOr9/qsfyLokx+r6wRBMHn/58Xn3x+/Rzeyq3Z0cNSk/Qym37VXyyQmdkddRPRlQVff1rw16t31Oon54acUqSoqNsdQqyaveXt/8v+MkQXTIkXaN6dNC3B0/U276mEd2S3LfbN+N9zmKxaIifp5Ls1N7ptbgqITbKffwDAAB4Q7UKwtrlw7rIbrUor9YXiuqirOio01ctWCwWLfhJtv6zZb/sVoueXlE1alY7pi8EAAAAPFCQBX/J63/6B4i/rv62yUVZLpeRyxjZbVb9v492updf/8LnfosRAIC2pKikXAkx/i/WaovSE6L15NXDNLxrkrLuXyJJ+setYzS86+mCkZE1Rv7JyeqonKyOqnQZLfp4l346MkPtT42kVOEy7oKYmiM0SVJK+2j38tKKSu0tPKmxj63Uj4eka3BGggZnJOjuU6MR1XRdjUGRqmeUGFfrPHq1MT2TNaZnsm4+J0u9UuLc7aNsVl13Rjev61itFndBVm3x0VF1Hkf1OtFWm/L6p7qLsgZ0Pl2QJUnn9Tv9+bHmTBgbH77AawGOxWJR54QY/WbS4Dr3+SKpnecF32c2MKJRY6xWi0dBlq+ibFY9fEndIqvuye3cBWLTx2bp7Q0/6PLhGU0aNTYjKbbONHuStPj2s/TlD8XKzap7sYPNanEfx4tvP1v/2vCDflbjOHj55jO069Bx9U1tX2fdpnLYre7jsmdK1WN12Fo+yl+wLLxmuD7fddhjmsqHfzxATy7frsW3n9XAmmjNuC4ZANAUFGUhrLVz2nX16K51lsdFnyrKqjVk7cjuHTSyewe9vvY7j20AAAAAQGu0cOFCLViwQAUFBRoyZIieeuopjR49Omj7r/kDW1wTv3sZY3T2oyv0fWGJv8MCAKDNevzdbXVG/Kn2x5Xb9ejSbUGOKHiuGpWp42WV2n3ouOJjovTh1we9trvujG666/w+SoyJ0sFjperU3qllW/brN4s369axvfTTUZl11vFWgFQfm9XiHlVKqioqirL5dlGE025T9+R2TdpfUwzqkhCQ7dZWs5irocfezmnXk1cPk9S8EZFak5T20fr0/nENjiBV08JrhuuFVTv163pG1EqMdfhUgJbZIVa3ju3lsSw6yqZ+afE+xdEUsQ67Nj58gbtAMRJMzO6sidmdPZZdf2YP9zSXAAAAjaFaBRHJ2/SFNWUkxdRpCwAAAACtycsvv6yZM2fq2WefVU5Ojp544gmNHz9e27ZtU0pK8KfQuGRo3Sv0val0GZVVuHTFMx9TkAUAIbBq+0FdObJu0QmaJtSF0dV2/PYiVbiM+jzwjiTpL6u/rVOU9fH2g/rzhzu0YtsBb5sIC10SY/Tgxf2V06OjvjlwTHabVZMWrtIrv8jVyfJK/fz5z3T16Ey9+Nke5fVP0QdfH1RZhUv3TeinScPS1Tkhps42K11Gh04VXR0vq9QHXx3Q2L6dFOs4fb44Jb6qeChvQKryBngfZQpNFx1l08aHL5DNamm0yMjbKE9tla8FWZL3YqFI0NaL79A6GFUNlcUY5AAAX1Ctgog0ID1e/1z/Q73D53apUZQVXU/hFgAAAABEsscff1zTpk3T1KlTJUnPPvusFi9erOeff16zZs0Kejy3/v2Lekd1qHQZ/emDb7Ry6wF9tutwkCMDANT0+hffUZTVQuFUGG21WuSoNTX1im371Te1vcbMXx7UWBpy74S+euXzPdp16ISW3H623lj3na4a3VVdEmNks1o8Rs4Z2a5qSsCanyuqb8+7PNu9zOUyDU7LbbNa3EVXcU67LhoceQUskYziGwCt1b7iUknSD0UnQxwJACASUJSFiPSLc7J02bAuSo33Pqd9Wo3lJWWVwQoLAAAAAIKirKxMa9eu1ezZs93LrFar8vLytHr16pDF1X3W4pDtGwDgm7N7dwp1CBEv3Aqja5v6wuehDsFt7iUD9bMzuslmtXhMkTYgfUCLt91QQRYAAIGyt4gRnwEAvqMoCxHJYrHUW5AlSfYaV1ZF0vzkAAAAbVW7EEw53T6ar0OIXAcPHlRlZaVSUz2n2UlNTdXWrVu9rlNaWqrS0lL3/4uLi/0Syy1je+qZld/4ZVsAgMC7dWzPUIcQ0ZpTGB2oHFzTW7edqUsXrvL7dr351UX9tejjXRrZPUkTBqZpxbb9mjyqq0Z0S5IkHS+tCMnnewAAgiGekQABAE3ANyO0WvMvH6xlW/fr8uFdQh0KAAAAGpHXP1WXDElXdkZC0PZ5cXa6/rNlv87o0SFo+wRCad68eZo7d67ft3vfhH666aweGvGb//h9223BBQNSZbdZdEZWR3VOiJHdatE3B46puKRc7Zx2De6SoMMnytTOYdeJskoN7pKgzXuLtfvwcU0e2VWb9xar0mWU1C5KJ8td6pwQrSMnytS9YztF2awqraiU027TzoPHZbNKmR1iVVFp5LRbZbdZ5XIZFZ8sV3SUTfZTI45YLRb36COVLqPqgUiMqfrXcur/LiNVuFxy2m0ej8kYI8upRiVllXLarbJaLR7LfXGstEJxp37Ur163qduoqdJlZKsxqkpFpcvjoq6mrFsdk6Rmx1ObMUYuozr7kaST5ZWKjvLs55KySsU4PJfVnsrLW5uG2jemtKJSUVZri0anqW+f3p7bY6UVauewuZdX97mkOsfDsdIKOWxWnSirUEJMlEorXJIkh61uvMUny7X70AkNTI93b6vm9ssrjRz2qmOjrMKlKJtFZZUuOWxWfV9YorT4aNlt1joxl1e6FGWzqqzC5V7f2+M7eKxUHWId7teSMadfV9XxlJRVym6rmtLNGKNKV1VsFS6j0gqX2jlsOl5aqfgYu9djsLSiUkUnyuWwW5UY61BJWaWio6x+O17bsuYURgcqB9c0JDNRvVLitH3/sRZtp1vHWH176ITm/HiAJg7urLJKl1Ljo+tc+DrtnCz37QtrTQtIQRYAoDW7OLuz3tuyT6O7cz4JANA4i6l5NqONKi4uVkJCgoqKihQfHx/qcAAAEYQc0nL0IQCgOdp6/igrK1NsbKxee+01TZo0yb18ypQpKiws1FtvvVVnHW+jdGRmZrbZPgQANE9bz8E//PCDunTpoo8//li5ubnu5ffee6/ef/99ffrpp3XWIQcDAPyhredgf6APAQDN0ZL8wbxuAAAAAABEGIfDoREjRmjZsmXuZS6XS8uWLfP4gbgmp9Op+Ph4jz8AANA0ycnJstls2rdvn8fyffv2KS0tzes65GAAAAAAaJsoygIAAAAAIALNnDlTf/7zn/WXv/xFW7Zs0S233KLjx49r6tSpoQ4NAIBWqzmF0QAAAACAtonJ3QEAAAAAiECTJ0/WgQMH9NBDD6mgoEBDhw7V0qVLlZqaGurQAABo1WbOnKkpU6Zo5MiRGj16tJ544gkKowEAAAAAdVCUBQAAAABAhJoxY4ZmzJgR6jAAAGhTKIwGAAAAAPiCoiwAAAAAAAAAAJqAwmgAAAAAQGOsoQ4AAAAAAAAAAAAAAAAAAFoTirIAAAAAAAAAAAAAAAAAwI8oygIAAAAAAAAAAAAAAAAAP6IoCwAAAAAAAAAAAAAAAAD8iKIsAAAAAAAAAAAAAAAAAPAjirIAAAAAAAAAAAAAAAAAwI8oygIAAAAAAAAAAAAAAAAAP6IoCwAAAAAAAAAAAAAAAAD8iKIsAAAAAAAAAAAAAAAAAPAje6gDCAfGGElScXFxiCMBAESa6txRnUvQdORhAEBzkINbjhwMAGgOcnDLkYMBAM1BDm45cjAAoDlakoMpypJ09OhRSVJmZmaIIwEARKqjR48qISEh1GFEJPIwAKAlyMHNRw4GALQEObj5yMEAgJYgBzcfORgA0BLNycEWQzm1XC6XfvjhB7Vv314Wi6VF2youLlZmZqb27Nmj+Ph4P0XYutBHjaOPGkcfNY4+8k1L+8kYo6NHjyo9PV1WK7MCN4e/8nAkHvORGLMUmXFHYsxSZMYdiTFLxB1M/oqZHNxy5ODIilmKzLgjMWaJuIMpEmOWIjNucnD4IAdHVsxSZMYdiTFLxB1MkRizFJlxk4PDBzk4smKWIjPuSIxZIu5gisSYpciMOxxyMCNlSbJarcrIyPDrNuPj4yPmQAwV+qhx9FHj6KPG0Ue+aUk/cVVSy/g7D0fiMR+JMUuRGXckxixFZtyRGLNE3MHkj5jJwS1DDo7MmKXIjDsSY5aIO5giMWYpMuMmB4ceOTgyY5YiM+5IjFki7mCKxJilyIybHBx65ODIjFmKzLgjMWaJuIMpEmOWIjPuUOZgyqgBAAAAAAAAAAAAAAAAwI8oygIAAAAAAAAAAAAAAAAAP6Ioy8+cTqfmzJkjp9MZ6lDCFn3UOPqocfRR4+gj39BPrUckPpeRGLMUmXFHYsxSZMYdiTFLxB1MkRgzGhaJz2kkxixFZtyRGLNE3MEUiTFLkRl3JMaMhkXicxqJMUuRGXckxiwRdzBFYsxSZMYdiTGjYZH4nEZizFJkxh2JMUvEHUyRGLMUmXGHQ8wWY4wJ2d4BAAAAAAAAAAAAAAAAoJVhpCwAAAAAAAAAAAAAAAAA8COKsgAAAAAAAAAAAAAAAADAjyjKAgAAAAAAAAAAAAAAAAA/oigLAAAAAAAAAAAAAAAAAPyIoiw/Wrhwobp3767o6Gjl5OTos88+C3VIIfPwww/LYrF4/PXr1899/8mTJ3XbbbepY8eOiouL0xVXXKF9+/aFMOLA++CDD/TjH/9Y6enpslgsevPNNz3uN8booYceUufOnRUTE6O8vDx9/fXXHm0OHz6sa6+9VvHx8UpMTNSNN96oY8eOBfFRBF5j/XT99dfXObYmTJjg0aY199O8efM0atQotW/fXikpKZo0aZK2bdvm0caX19fu3bs1ceJExcbGKiUlRffcc48qKiqC+VACxpc+Gjt2bJ3jaPr06R5tWnMftUahzMH+yHm+HG8rV67U8OHD5XQ61atXLy1atMjnGIOVgzZs2KCzzz5b0dHRyszM1KOPPlonlldffVX9+vVTdHS0Bg8erCVLljQ7bn/lBH/GHcz3aV+OCV9fG8F87/RX3M8884yys7MVHx+v+Ph45ebm6p133gnrfvYl7nDrZ2/mz58vi8WiO++8070sXPsbgUcObhg5mBxMDg6PfvYl7nDrZ2/IwaiJHNy4SMzD5GByMDk49P3sDTkYNZGDG0cOJgeTg0Pfz77EHW797E2ryMEGfvHSSy8Zh8Nhnn/+efPll1+aadOmmcTERLNv375QhxYSc+bMMQMHDjR79+51/x04cMB9//Tp001mZqZZtmyZWbNmjTnjjDPMmDFjQhhx4C1ZssT86le/Mv/4xz+MJPPGG2943D9//nyTkJBg3nzzTbN+/XpzySWXmB49epiSkhJ3mwkTJpghQ4aYTz75xHz44YemV69e5uqrrw7yIwmsxvppypQpZsKECR7H1uHDhz3atOZ+Gj9+vHnhhRfMpk2bTH5+vrnoootM165dzbFjx9xtGnt9VVRUmEGDBpm8vDyzbt06s2TJEpOcnGxmz54diofkd7700bnnnmumTZvmcRwVFRW572/tfdTahDoHtzTn+XK87dixw8TGxpqZM2eazZs3m6eeesrYbDazdOlSn2IMRg4qKioyqamp5tprrzWbNm0yL774oomJiTF/+tOf3G1WrVplbDabefTRR83mzZvNAw88YKKioszGjRubFbc/coK/4w7W+7Qvx0RTXhvBeu/0Z9z//Oc/zeLFi81XX31ltm3bZu6//34TFRVlNm3aFLb97Evc4dbPtX322Weme/fuJjs729xxxx3u5eHa3wisUD8f5OAq5OAq5GByMDk4vPobgRXq5yMScrAxkZmHycHkYHJw6Pu5NnIwagr180EOJgfXRA4mB5ODw6u/60NRlp+MHj3a3Hbbbe7/V1ZWmvT0dDNv3rwQRhU6c+bMMUOGDPF6X2FhoYmKijKvvvqqe9mWLVuMJLN69eogRRhatZO5y+UyaWlpZsGCBe5lhYWFxul0mhdffNEYY8zmzZuNJPP555+727zzzjvGYrGY77//PmixB1N9H3ouvfTSetdpa/20f/9+I8m8//77xhjfXl9LliwxVqvVFBQUuNs888wzJj4+3pSWlgb3AQRB7T4ypupDRs3kXVtb66NIF+oc3NKc58vxdu+995qBAwd6bHvy5Mlm/PjxTY43UDnoj3/8o0lKSvJ4jdx3332mb9++7v//9Kc/NRMnTvSIJycnx/ziF79octzG+CcnBDruQL1P+3JMtOS1Eaj3zkDHnZSUZJ577rmI6efacRsT3v189OhR07t3b/Pee+95xBlp/Q3/CfXzQQ4mBzeEHEwO9gU5mBwcqUL9fERaDjYmMvMwOZgcTA42IY+bHIzaQv18kIPJwQ0hB5ODfUEODn4OZvpCPygrK9PatWuVl5fnXma1WpWXl6fVq1eHMLLQ+vrrr5Wenq6srCxde+212r17tyRp7dq1Ki8v9+ivfv36qWvXrm22v3bu3KmCggKPPklISFBOTo67T1avXq3ExESNHDnS3SYvL09Wq1Wffvpp0GMOpZUrVyolJUV9+/bVLbfcokOHDrnva2v9VFRUJEnq0KGDJN9eX6tXr9bgwYOVmprqbjN+/HgVFxfryy+/DGL0wVG7j6r9/e9/V3JysgYNGqTZs2frxIkT7vvaWh9FsnDJwS3Jeb4cb6tXr/bYRnUbfzxGf+Wg1atX65xzzpHD4fCIcdu2bTpy5EjAHkdLc0Kg4w7U+3RjMbX0tRGo985AxV1ZWamXXnpJx48fV25ubsT0c+24q4VrP992222aOHFinW1HSn/Dv8Ll+SAHk4PrQw4mBzeEHEwOjmTh8nxEcg6WIjsPk4O9x0QOjox+JgeTgyNZuDwf5GBycH3IweTghpCDQ5eD7U1qDa8OHjyoyspKjydVklJTU7V169YQRRVaOTk5WrRokfr27au9e/dq7ty5Ovvss7Vp0yYVFBTI4XAoMTHRY53U1FQVFBSEJuAQq37c3o6h6vsKCgqUkpLicb/dbleHDh3aVL9NmDBBl19+uXr06KFvvvlG999/vy688EKtXr1aNputTfWTy+XSnXfeqTPPPFODBg2SJJ9eXwUFBV6Pter7WhNvfSRJ11xzjbp166b09HRt2LBB9913n7Zt26Z//OMfktpWH0W6cMjBLc15vhxv9bUpLi5WSUmJYmJimh2/v3JQQUGBevToUe/jSEpKqvdxNPd15Y+cEMi4A/k+3dgxceTIkWa/NgL53unvuDdu3Kjc3FydPHlScXFxeuONNzRgwADl5+eHdT/XF7cUnv0sSS+99JK++OILff7553Xui4TjGv5HDiYHk4M925CDycGBipscjNrIwS3PwTX3E2l5mBxMDiYHBy9ucjBqIweTg8nBnm3IweTgQMXd2nIwRVkIiAsvvNB9Ozs7Wzk5OerWrZteeeWVFidrtG1XXXWV+/bgwYOVnZ2tnj17auXKlRo3blwIIwu+2267TZs2bdJHH30U6lDCVn19dPPNN7tvDx48WJ07d9a4ceP0zTffqGfPnsEOExGOnBc64Z4TIvV9OpLeO/v27av8/HwVFRXptdde05QpU/T++++HJJamqC/uAQMGhGU/79mzR3fccYfee+89RUdHhyQGwBtycOiQgwODHBx45GDAP8jBoUMODgxycOCRgwH/IAeHDjk4MMjBgUcODj2mL/SD5ORk2Ww27du3z2P5vn37lJaWFqKowktiYqL69Omj7du3Ky0tTWVlZSosLPRo05b7q/pxN3QMpaWlaf/+/R73V1RU6PDhw2223yQpKytLycnJ2r59u6S2008zZszQ22+/rRUrVigjI8O93JfXV1pamtdjrfq+1qK+PvImJydHkjyOo7bQR61BOObgpuY8X463+trEx8e3+Mu2v3JQSx6Hv56r5uSEQMUd6Pfpxo6J5r42Av3e6e+4HQ6HevXqpREjRmjevHkaMmSI/vCHP4R9P9cXtzfh0M9r167V/v37NXz4cNntdtntdr3//vt68sknZbfblZqaGtb9jcAIx+eDHNz0x0EODp/3KnIwOZgcDF+F4/MRaTm45n4iPQ+Tg8nB5GByMIInHJ8PcjA5WCIHBytucnBw4m6NOZiiLD9wOBwaMWKEli1b5l7mcrm0bNkyj/k427Jjx47pm2++UefOnTVixAhFRUV59Ne2bdu0e/fuNttfPXr0UFpamkefFBcX69NPP3X3SW5urgoLC7V27Vp3m+XLl8vlcrnfINui7777TocOHVLnzp0ltf5+MsZoxowZeuONN7R8+fI6w5z68vrKzc3Vxo0bPT4cvvfee4qPj3cPVxnJGusjb/Lz8yXJ4zhqzX3UmoRjDm5qzvPleMvNzfXYRnUbfzxGf+Wg3NxcffDBByovL/eIsW/fvkpKSgr445CalxP8HXew3qcbi6mpr41gvXf6O+7aXC6XSktLw7afG4vbm3Do53Hjxmnjxo3Kz893/40cOVLXXnut+3Yk9Tf8IxyfD3IwOZgcTA4mB4d3f8M/wvH5iLQcLLWePEwOJgeTg8nBCJ5wfD7IweRgcjA5mBwc3v0tSTLwi5deesk4nU6zaNEis3nzZnPzzTebxMREU1BQEOrQQuLuu+82K1euNDt37jSrVq0yeXl5Jjk52ezfv98YY8z06dNN165dzfLly82aNWtMbm6uyc3NDXHUgXX06FGzbt06s27dOiPJPP7442bdunXm22+/NcYYM3/+fJOYmGjeeusts2HDBnPppZeaHj16mJKSEvc2JkyYYIYNG2Y+/fRT89FHH5nevXubq6++OlQPKSAa6qejR4+aX/7yl2b16tVm586d5j//+Y8ZPny46d27tzl58qR7G625n2655RaTkJBgVq5cafbu3ev+O3HihLtNY6+viooKM2jQIHPBBReY/Px8s3TpUtOpUycze/bsUDwkv2usj7Zv325+/etfmzVr1pidO3eat956y2RlZZlzzjnHvY3W3ketTahzcEtzni/H244dO0xsbKy55557zJYtW8zChQuNzWYzS5cu9SnGYOSgwsJCk5qaaq677jqzadMm89JLL5nY2Fjzpz/9yd1m1apVxm63m8cee8xs2bLFzJkzx0RFRZmNGzc2OW5/5QR/xx2s92lfjommvDaC9d7pz7hnzZpl3n//fbNz506zYcMGM2vWLGOxWMy7774btv3cWNzh2M/1Offcc80dd9zh/n+49jcCK9TPBzm4Cjm4CjmYHEwODq/+RmCF+vmIhBxsTGTmYXIwOZgcHPp+rg85GMaE/vkgB5ODayIHk4PJweHV3/WhKMuPnnrqKdO1a1fjcDjM6NGjzSeffBLqkEJm8uTJpnPnzsbhcJguXbqYyZMnm+3bt7vvLykpMbfeeqtJSkoysbGx5rLLLjN79+4NYcSBt2LFCiOpzt+UKVOMMca4XC7z4IMPmtTUVON0Os24cePMtm3bPLZx6NAhc/XVV5u4uDgTHx9vpk6dao4ePRqCRxM4DfXTiRMnzAUXXGA6depkoqKiTLdu3cy0adPqvPG15n7y1jeSzAsvvOBu48vra9euXebCCy80MTExJjk52dx9992mvLw8yI8mMBrro927d5tzzjnHdOjQwTidTtOrVy9zzz33mKKiIo/ttOY+ao1CmYP9kfN8Od5WrFhhhg4dahwOh8nKyvJ43TcmWDlo/fr15qyzzjJOp9N06dLFzJ8/v04sr7zyiunTp49xOBxm4MCBZvHixc2K2585wZ9xB/N92pdjwtfXRjDfO/0V9w033GC6detmHA6H6dSpkxk3bpz7S3C49nNjcYdjP9en9hfhcO1vBB45uGHkYHIwOTg8+rmxuMOxn+tDDkY1cnDjIjEPk4PJweTg0PdzfcjBqEYObhw5mBxMDg59PzcWdzj2c30iPQdbjDFGAAAAAAAAAAAAAAAAAAC/sIY6AAAAAAAAAAAAAAAAAABoTSjKAgAAAAAAAAAAAAAAAAA/oigLAAAAAAAAAAAAAAAAAPyIoiwAAAAAAAAAAAAAAAAA8COKsgAAAAAAAAAAAAAAAADAjyjKAgAAAAAAAAAAAAAAAAA/oigLAAAAAAAAAAAAAAAAAPyIoiwAAAAAAAAAAAAAAAAA8COKsgAAAAAAAAAAAAAAAADAjyjKAgAAAAAAAAAAAAAAAAA/oigLAAAAAAAAAAAAAAAAAPyIoiwAAAAAAAAAAAAAAAAA8KP/H9No0puuzac2AAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "agent.train(num_frames)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NrUA32xDS7Eq"
      },
      "source": [
        "## Test\n",
        "Run the trained agent (1 episode)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BgfgUuwxS7Eq",
        "outputId": "53670332-cd30-412d-a50e-88cc14dfef41"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "score:  -124.53971535704629\n"
          ]
        }
      ],
      "source": [
        "# test\n",
        "video_folder = \"videos/sac\"\n",
        "agent.test(video_folder=video_folder)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NnSiKGcrS7Eq"
      },
      "source": [
        "## Render"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "YCo5tsEtS7Eq",
        "outputId": "447b7971-4cd7-4ff1-d7a4-b51ad14e2dff"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
              "        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n",
              "        </video>\n",
              "        "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Played: videos/sac/rl-video-episode-0.mp4\n"
          ]
        }
      ],
      "source": [
        "import base64\n",
        "import glob\n",
        "import io\n",
        "import os\n",
        "\n",
        "from IPython.display import HTML, display\n",
        "\n",
        "\n",
        "def ipython_show_video(path: str) -> None:\n",
        "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
        "    if not os.path.isfile(path):\n",
        "        raise NameError(\"Cannot access: {}\".format(path))\n",
        "\n",
        "    video = io.open(path, \"r+b\").read()\n",
        "    encoded = base64.b64encode(video)\n",
        "\n",
        "    display(\n",
        "        HTML(\n",
        "            data=\"\"\"\n",
        "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
        "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
        "        </video>\n",
        "        \"\"\".format(\n",
        "                encoded.decode(\"ascii\")\n",
        "            )\n",
        "        )\n",
        "    )\n",
        "\n",
        "\n",
        "def show_latest_video(video_folder: str) -> str:\n",
        "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
        "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
        "    latest_file = max(list_of_files, key=os.path.getctime)\n",
        "    ipython_show_video(latest_file)\n",
        "    return latest_file\n",
        "\n",
        "\n",
        "latest_file = show_latest_video(video_folder=video_folder)\n",
        "print(\"Played:\", latest_file)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "D-zmDSy7S7Eq"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "pgayn",
      "language": "python",
      "name": "pgayn"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.9"
    },
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}