RL/actor_critic_cartpole_v1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "RL - Actor Critic.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "_jQ1tEQCxwRx"
      ]
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_jQ1tEQCxwRx"
      },
      "source": [
        "##### Copyright 2020 The TensorFlow Authors."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V_sgB_5dx1f1"
      },
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p62G8M_viUJp"
      },
      "source": [
        "# Playing CartPole with the Actor-Critic Method\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-mJ2i6jvZ3sK"
      },
      "source": [
        "Open this file in Google Colab: <a href=\"https://colab.research.google.com/github/GioBonvi/MachineLearning/blob/main/VAE/VAE.ipynb\" target=\"_blank\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kFgN7h_wiUJq"
      },
      "source": [
        "This tutorial demonstrates how to implement the [Actor-Critic](https://papers.nips.cc/paper/1786-actor-critic-algorithms.pdf) method using TensorFlow to train an agent on the [Open AI Gym](https://gym.openai.com/) CartPole-V1 environment.\n",
        "The reader is assumed to have some familiarity with [policy gradient methods](https://papers.nips.cc/paper/1713-policy-gradient-methods-for-reinforcement-learning-with-function-approximation.pdf) of reinforcement learning. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_kA10ZKRR0hi"
      },
      "source": [
        "**Actor-Critic methods**\n",
        "\n",
        "Actor-Critic methods are [temporal difference (TD) learning](https://en.wikipedia.org/wiki/Temporal_difference_learning) methods that represent the policy function independent of the value function. \n",
        "\n",
        "A policy function (or policy) returns a probability distribution over actions that the agent can take based on the given state.\n",
        "A value function determines the expected return for an agent starting at a given state and acting according to a particular policy forever after.\n",
        "\n",
        "In the Actor-Critic method, the policy is referred to as the *actor* that proposes a set of possible actions given a state, and the estimated value function is referred to as the *critic*, which evaluates actions taken by the *actor* based on the given policy.\n",
        "\n",
        "In this tutorial, both the *Actor* and *Critic* will be represented using one neural network with two outputs.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rBfiafKSRs2k"
      },
      "source": [
        "**CartPole-v1**\n",
        "\n",
        "In the [CartPole-v1 environment](https://gym.openai.com/envs/CartPole-v1), a pole is attached to a cart moving along a frictionless track. \n",
        "The pole starts upright and the goal of the agent is to prevent it from falling over by applying a force of -1 or +1 to the cart. \n",
        "A reward of +1 is given for every time step the pole remains upright.\n",
        "An episode ends when (1) the pole is more than 15 degrees from vertical or (2) the cart moves more than 2.4 units from the center.\n",
        "\n",
        "<center>\n",
        "  <figure>\n",
        "    <image src=\"https://github.com/tensorflow/docs/blob/master/site/en/tutorials/reinforcement_learning/images/cartpole-v0.gif?raw=1\">\n",
        "    <figcaption>\n",
        "      Trained actor-critic model in Cartpole-v1 environment\n",
        "    </figcaption>\n",
        "  </figure>\n",
        "</center>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XSNVK0AeRoJd"
      },
      "source": [
        "The problem is considered \"solved\" when the average total reward for the episode reaches 475 over 100 consecutive trials."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "glLwIctHiUJq"
      },
      "source": [
        "## Setup\n",
        "\n",
        "Import necessary packages and configure global settings.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "13l6BbxKhCKp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ca3fd970-96f8-4b66-de28-ea1fdffc0468"
      },
      "source": [
        "!pip install gym\n",
        "!pip install pyglet\n",
        "\n",
        "# Install additional packages for visualization\n",
        "!sudo apt-get install -y xvfb python-opengl\n",
        "!pip install pyvirtualdisplay\n",
        "!pip install git+https://github.com/tensorflow/docs"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: gym in /usr/local/lib/python3.7/dist-packages (0.17.3)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from gym) (1.4.1)\n",
            "Requirement already satisfied: numpy>=1.10.4 in /usr/local/lib/python3.7/dist-packages (from gym) (1.19.5)\n",
            "Requirement already satisfied: cloudpickle<1.7.0,>=1.2.0 in /usr/local/lib/python3.7/dist-packages (from gym) (1.3.0)\n",
            "Requirement already satisfied: pyglet<=1.5.0,>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from gym) (1.5.0)\n",
            "Requirement already satisfied: future in /usr/local/lib/python3.7/dist-packages (from pyglet<=1.5.0,>=1.4.0->gym) (0.16.0)\n",
            "Requirement already satisfied: pyglet in /usr/local/lib/python3.7/dist-packages (1.5.0)\n",
            "Requirement already satisfied: future in /usr/local/lib/python3.7/dist-packages (from pyglet) (0.16.0)\n",
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "Suggested packages:\n",
            "  libgle3\n",
            "The following NEW packages will be installed:\n",
            "  python-opengl xvfb\n",
            "0 upgraded, 2 newly installed, 0 to remove and 37 not upgraded.\n",
            "Need to get 1,281 kB of archives.\n",
            "After this operation, 7,686 kB of additional disk space will be used.\n",
            "Get:1 http://archive.ubuntu.com/ubuntu bionic/universe amd64 python-opengl all 3.1.0+dfsg-1 [496 kB]\n",
            "Get:2 http://archive.ubuntu.com/ubuntu bionic-updates/universe amd64 xvfb amd64 2:1.19.6-1ubuntu4.9 [784 kB]\n",
            "Fetched 1,281 kB in 3s (508 kB/s)\n",
            "debconf: unable to initialize frontend: Dialog\n",
            "debconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 76, <> line 2.)\n",
            "debconf: falling back to frontend: Readline\n",
            "debconf: unable to initialize frontend: Readline\n",
            "debconf: (This frontend requires a controlling tty.)\n",
            "debconf: falling back to frontend: Teletype\n",
            "dpkg-preconfigure: unable to re-open stdin: \n",
            "Selecting previously unselected package python-opengl.\n",
            "(Reading database ... 155013 files and directories currently installed.)\n",
            "Preparing to unpack .../python-opengl_3.1.0+dfsg-1_all.deb ...\n",
            "Unpacking python-opengl (3.1.0+dfsg-1) ...\n",
            "Selecting previously unselected package xvfb.\n",
            "Preparing to unpack .../xvfb_2%3a1.19.6-1ubuntu4.9_amd64.deb ...\n",
            "Unpacking xvfb (2:1.19.6-1ubuntu4.9) ...\n",
            "Setting up python-opengl (3.1.0+dfsg-1) ...\n",
            "Setting up xvfb (2:1.19.6-1ubuntu4.9) ...\n",
            "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n",
            "Collecting pyvirtualdisplay\n",
            "  Downloading PyVirtualDisplay-2.2-py3-none-any.whl (15 kB)\n",
            "Collecting EasyProcess\n",
            "  Downloading EasyProcess-0.3-py2.py3-none-any.whl (7.9 kB)\n",
            "Installing collected packages: EasyProcess, pyvirtualdisplay\n",
            "Successfully installed EasyProcess-0.3 pyvirtualdisplay-2.2\n",
            "Collecting git+https://github.com/tensorflow/docs\n",
            "  Cloning https://github.com/tensorflow/docs to /tmp/pip-req-build-w84_zica\n",
            "  Running command git clone -q https://github.com/tensorflow/docs /tmp/pip-req-build-w84_zica\n",
            "Requirement already satisfied: astor in /usr/local/lib/python3.7/dist-packages (from tensorflow-docs==0.0.0.dev0) (0.8.1)\n",
            "Requirement already satisfied: absl-py in /usr/local/lib/python3.7/dist-packages (from tensorflow-docs==0.0.0.dev0) (0.12.0)\n",
            "Requirement already satisfied: protobuf>=3.14 in /usr/local/lib/python3.7/dist-packages (from tensorflow-docs==0.0.0.dev0) (3.17.3)\n",
            "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from tensorflow-docs==0.0.0.dev0) (3.13)\n",
            "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.7/dist-packages (from protobuf>=3.14->tensorflow-docs==0.0.0.dev0) (1.15.0)\n",
            "Building wheels for collected packages: tensorflow-docs\n",
            "  Building wheel for tensorflow-docs (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for tensorflow-docs: filename=tensorflow_docs-0.0.0.dev0-py3-none-any.whl size=157706 sha256=dcb746107ac2fdd2421fb1097cd09e3c6826462a9418056ea717ab3731b24959\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-uunndflo/wheels/cc/c4/d8/5341e93b6376c5c929c49469fce21155eb69cef1a4da4ce32c\n",
            "Successfully built tensorflow-docs\n",
            "Installing collected packages: tensorflow-docs\n",
            "Successfully installed tensorflow-docs-0.0.0.dev0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WBeQhPi2S4m5"
      },
      "source": [
        "import gym\n",
        "import numpy as np\n",
        "import os\n",
        "import statistics\n",
        "import tensorflow as tf\n",
        "import tensorflow_docs.vis.embed as embed\n",
        "import tqdm\n",
        "\n",
        "from collections import deque\n",
        "from IPython import display as ipythondisplay\n",
        "from matplotlib import pyplot as plt\n",
        "from PIL import Image\n",
        "from pyvirtualdisplay import Display\n",
        "from tensorflow.keras import layers\n",
        "from typing import Any, List, Sequence, Tuple"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tT4N3qYviUJr"
      },
      "source": [
        "# This is required to user env.render() later on.\n",
        "display = Display(visible=0, size=(400, 300))\n",
        "display.start()\n",
        "\n",
        "# Environment setup.\n",
        "max_episodes = 10000\n",
        "max_steps_per_episode = 500\n",
        "\n",
        "# Cartpole-v0 is considered solved if average reward is >= 195 over 100 consecutive trials.\n",
        "min_episodes_criterion = 100\n",
        "reward_threshold = 475\n",
        "\n",
        "# Create the environment\n",
        "env = gym.make(\"CartPole-v1\")\n",
        "env._max_episode_steps = max_steps_per_episode\n",
        "\n",
        "# Set seed for experiment reproducibility.\n",
        "# Try changing the seed and see if the learning patterns evolve differently.\n",
        "seed = 1\n",
        "env.seed(seed)\n",
        "tf.random.set_seed(seed)\n",
        "np.random.seed(seed)\n",
        "\n",
        "# Small epsilon value for stabilizing division operations\n",
        "eps = np.finfo(np.float32).eps.item()\n",
        "\n",
        "# Outputs of the NN mode == number of possible actions.\n",
        "num_actions = env.action_space.n  # 2\n",
        "# Hidden units of the NN model.\n",
        "num_hidden_units = 128\n",
        "# Learning rate.\n",
        "lr = 0.01\n",
        "# Discount factor for future rewards\n",
        "gamma = 0.99\n",
        "# Output folder for animations.\n",
        "animation_dir = 'animations'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AOUCe2D0iUJu"
      },
      "source": [
        "## Model\n",
        "\n",
        "The *Actor* and *Critic* will be modeled using one neural network that generates the action probabilities and critic value respectively. This tutorial uses model subclassing to define the model. \n",
        "\n",
        "During the forward pass, the model will take in the state as the input and will output both action probabilities and critic value $V$, which models the state-dependent [value function](https://spinningup.openai.com/en/latest/spinningup/rl_intro.html#value-functions). The goal is to train a model that chooses actions based on a policy $\\pi$ that maximizes expected [return](https://spinningup.openai.com/en/latest/spinningup/rl_intro.html#reward-and-return).\n",
        "\n",
        "For Cartpole-v0, there are four values representing the state: cart position, cart-velocity, pole angle and pole velocity respectively. The agent can take two actions to push the cart left (0) and right (1) respectively.\n",
        "\n",
        "Refer to [OpenAI Gym's CartPole-v1 wiki page](http://www.derongliu.org/adp/adp-cdrom/Barto1983.pdf) for more information.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aXKbbMC-kmuv"
      },
      "source": [
        "class ActorCritic(tf.keras.Model):\n",
        "  \"\"\"Combined actor-critic network.\"\"\"\n",
        "\n",
        "  def __init__(self, num_actions: int, num_hidden_units: int):\n",
        "    \"\"\"Initialize.\"\"\"\n",
        "    super().__init__()\n",
        "\n",
        "    self.common = layers.Dense(num_hidden_units, activation=\"relu\")\n",
        "    self.actor = layers.Dense(num_actions)\n",
        "    self.critic = layers.Dense(1)\n",
        "\n",
        "  def call(self, inputs: tf.Tensor) -> Tuple[tf.Tensor, tf.Tensor]:\n",
        "    x = self.common(inputs)\n",
        "    return self.actor(x), self.critic(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hk92njFziUJw"
      },
      "source": [
        "## Training\n",
        "\n",
        "To train the agent, you will follow these steps:\n",
        "\n",
        "1. Run the agent on the environment to collect training data per episode.\n",
        "2. Compute expected return at each time step.\n",
        "3. Compute the loss for the combined actor-critic model.\n",
        "4. Compute gradients and update network parameters.\n",
        "5. Repeat 1-4 until either success criterion or max episodes has been reached.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R2nde2XDs8Gh"
      },
      "source": [
        "### 1. Collecting training data\n",
        "\n",
        "As in supervised learning, in order to train the actor-critic model, you need\n",
        "to have training data. However, in order to collect such data, the model would\n",
        "need to be \"run\" in the environment.\n",
        "\n",
        "Training data is collected for each episode. Then at each time step, the model's forward pass will be run on the environment's state in order to generate action probabilities and the critic value based on the current policy parameterized by the model's weights.\n",
        "\n",
        "The next action will be sampled from the action probabilities generated by the model, which would then be applied to the environment, causing the next state and reward to be generated.\n",
        "\n",
        "This process is implemented in the `run_episode` function, which uses TensorFlow operations so that it can later be compiled into a TensorFlow graph for faster training. Note that `tf.TensorArray`s were used to support Tensor iteration on variable length arrays."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5URrbGlDSAGx"
      },
      "source": [
        "# Wrap OpenAI Gym's `env.step` call as an operation in a TensorFlow function.\n",
        "# This would allow it to be included in a callable TensorFlow graph.\n",
        "\n",
        "def env_step(action: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\n",
        "  \"\"\"Returns state, reward and done flag given an action.\"\"\"\n",
        "\n",
        "  state, reward, done, _ = env.step(action)\n",
        "  return (state.astype(np.float32), \n",
        "          np.array(reward, np.int32), \n",
        "          np.array(done, np.int32))\n",
        "\n",
        "\n",
        "def tf_env_step(action: tf.Tensor) -> List[tf.Tensor]:\n",
        "  return tf.numpy_function(env_step, [action], \n",
        "                           [tf.float32, tf.int32, tf.int32])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a4qVRV063Cl9"
      },
      "source": [
        "\"\"\"\n",
        "render_episode() and run_episode() both run one episode, but\n",
        "- render_episode() is used to produce the animation of an episode\n",
        "- run_episode() is used for training\n",
        "\"\"\"\n",
        "\n",
        "def run_episode(\n",
        "    initial_state: tf.Tensor,  \n",
        "    model: tf.keras.Model, \n",
        "    max_steps: int) -> Tuple[tf.Tensor, tf.Tensor, tf.Tensor]:\n",
        "  \"\"\"Runs a single episode to collect training data.\"\"\"\n",
        "\n",
        "  action_probs = tf.TensorArray(dtype=tf.float32, size=0, dynamic_size=True)\n",
        "  values = tf.TensorArray(dtype=tf.float32, size=0, dynamic_size=True)\n",
        "  rewards = tf.TensorArray(dtype=tf.int32, size=0, dynamic_size=True)\n",
        "\n",
        "  state = initial_state\n",
        "  initial_state_shape = initial_state.shape\n",
        "  for t in tf.range(max_steps):\n",
        "    # Convert state into a batched tensor (batch size = 1)\n",
        "    state = tf.expand_dims(state, 0)\n",
        "  \n",
        "    # Run the model and get action probabilities and critic value\n",
        "    action_logits_t, value = model(state)\n",
        "  \n",
        "    # Sample next action from the action probability distribution\n",
        "    action = tf.squeeze(tf.random.categorical(action_logits_t, num_samples=1))\n",
        "    action_probs_t = tf.nn.softmax(action_logits_t)\n",
        "\n",
        "    # Store critic values\n",
        "    values = values.write(t, tf.squeeze(value))\n",
        "\n",
        "    # Store log probability of the action chosen\n",
        "    action_probs = action_probs.write(t, action_probs_t[0, action])\n",
        "  \n",
        "    # Apply action to the environment to get next state and reward\n",
        "    state, reward, done = tf_env_step(action)\n",
        "    # Tensor shape is lost during the loop and has to be recovered.\n",
        "    state.set_shape(initial_state_shape)\n",
        "  \n",
        "    # Store reward\n",
        "    rewards = rewards.write(t, reward)\n",
        "\n",
        "    if tf.cast(done, tf.bool):\n",
        "      break\n",
        "\n",
        "  action_probs = action_probs.stack()\n",
        "  values = values.stack()\n",
        "  rewards = rewards.stack()\n",
        "  \n",
        "  return action_probs, values, rewards\n",
        "\n",
        "\n",
        "def render_episode(\n",
        "    env: gym.Env,\n",
        "    model: tf.keras.Model,\n",
        "    max_steps: int,\n",
        "    image_path: str,\n",
        "    delta_step: int = 10):\n",
        "  \"\"\"Runs a single episode to render it.\"\"\"\n",
        "  images = []\n",
        "  state = tf.constant(env.reset(), dtype=tf.float32)\n",
        "  for timestep in range(0, max_steps):\n",
        "    state = tf.expand_dims(state, 0)\n",
        "    action_probs, _ = model(state)\n",
        "    action = np.argmax(np.squeeze(action_probs))\n",
        "\n",
        "    state, _, done, _ = env.step(action)\n",
        "    state = tf.constant(state, dtype=tf.float32)\n",
        "\n",
        "    # Render screen every 10 steps\n",
        "    if timestep % delta_step == 0:\n",
        "      screen = env.render(mode='rgb_array')\n",
        "      images.append(Image.fromarray(screen))\n",
        "  \n",
        "    if done:\n",
        "      break\n",
        "\n",
        "  # Save GIF image:\n",
        "  # loop=0: loop forever.\n",
        "  # duration=1: play each frame for 1ms.\n",
        "  images[0].save(\n",
        "      image_path, save_all=True, append_images=images[1:], loop=0, duration=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lBnIHdz22dIx"
      },
      "source": [
        "### 2. Computing expected returns\n",
        "\n",
        "The sequence of rewards for each timestep $t$, $\\{r_{t}\\}^{T}_{t=1}$ collected during one episode is converted into a sequence of expected returns $\\{G_{t}\\}^{T}_{t=1}$ in which the sum of rewards is taken from the current timestep $t$ to $T$ and each reward is multiplied with an exponentially decaying discount factor $\\gamma$:\n",
        "\n",
        "$$G_{t} = \\sum^{T}_{t'=t} \\gamma^{t'-t}r_{t'}$$\n",
        "\n",
        "Since $\\gamma\\in(0,1)$, rewards further out from the current timestep are given less weight.\n",
        "\n",
        "Intuitively, expected return simply implies that rewards now are better than rewards later. In a mathematical sense, it is to ensure that the sum of the rewards converges.\n",
        "\n",
        "To stabilize training, the resulting sequence of returns is also standardized (i.e. to have zero mean and unit standard deviation).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jpEwFyl315dl"
      },
      "source": [
        "def get_expected_return(\n",
        "    rewards: tf.Tensor, \n",
        "    gamma: float, \n",
        "    standardize: bool = True) -> tf.Tensor:\n",
        "  \"\"\"Compute expected returns per timestep.\"\"\"\n",
        "\n",
        "  n = tf.shape(rewards)[0]\n",
        "  returns = tf.TensorArray(dtype=tf.float32, size=n)\n",
        "\n",
        "  # Start from the end of `rewards` and accumulate reward sums\n",
        "  # into the `returns` array\n",
        "  rewards = tf.cast(rewards[::-1], dtype=tf.float32)\n",
        "  discounted_sum = tf.constant(0.0)\n",
        "  discounted_sum_shape = discounted_sum.shape\n",
        "  for i in tf.range(n):\n",
        "    discounted_sum = rewards[i] + gamma * discounted_sum\n",
        "    # Tensor shape is lost during the loop and has to be recovered.\n",
        "    discounted_sum.set_shape(discounted_sum_shape)\n",
        "    returns = returns.write(i, discounted_sum)\n",
        "  returns = returns.stack()[::-1]\n",
        "\n",
        "  if standardize:\n",
        "    returns = ((returns - tf.math.reduce_mean(returns)) / \n",
        "               (tf.math.reduce_std(returns) + eps))\n",
        "\n",
        "  return returns"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1hrPLrgGxlvb"
      },
      "source": [
        "### 3. The actor-critic loss\n",
        "\n",
        "Since a hybrid actor-critic model is used, the chosen loss function is a combination of actor and critic losses for training, as shown below:\n",
        "\n",
        "$$L = L_{actor} + L_{critic}$$\n",
        "\n",
        "#### Actor loss\n",
        "\n",
        "The actor loss is based on [policy gradients with the critic as a state dependent baseline](https://www.youtube.com/watch?v=EKqxumCuAAY&t=62m23s) and computed with single-sample (per-episode) estimates.\n",
        "\n",
        "$$L_{actor} = -\\sum^{T}_{t=1} log\\pi_{\\theta}(a_{t} | s_{t})[G(s_{t}, a_{t})  - V^{\\pi}_{\\theta}(s_{t})]$$\n",
        "\n",
        "where:\n",
        "- $T$: the number of timesteps per episode, which can vary per episode\n",
        "- $s_{t}$: the state at timestep $t$\n",
        "- $a_{t}$: chosen action at timestep $t$ given state $s$\n",
        "- $\\pi_{\\theta}$: is the policy (actor) parameterized by $\\theta$\n",
        "- $V^{\\pi}_{\\theta}$: is the value function (critic) also parameterized by $\\theta$\n",
        "- $G = G_{t}$: the expected return for a given state, action pair at timestep $t$\n",
        "\n",
        "A negative term is added to the sum since the idea is to maximize the probabilities of actions yielding higher rewards by minimizing the combined loss.\n",
        "\n",
        "<br>\n",
        "\n",
        "##### Advantage\n",
        "\n",
        "The $G - V$ term in our $L_{actor}$ formulation is called the [advantage](https://spinningup.openai.com/en/latest/spinningup/rl_intro.html#advantage-functions), which indicates how much better an action is given a particular state over a random action selected according to the policy $\\pi$ for that state.\n",
        "\n",
        "While it's possible to exclude a baseline, this may result in high variance during training. And the nice thing about choosing the critic $V$ as a baseline is that it trained to be as close as possible to $G$, leading to a lower variance.\n",
        "\n",
        "In addition, without the critic, the algorithm would try to increase probabilities for actions taken on a particular state based on expected return, which may not make much of a difference if the relative probabilities between actions remain the same.\n",
        "\n",
        "For instance, suppose that two actions for a given state would yield the same expected return. Without the critic, the algorithm would try to raise the probability of these actions based on the objective $J$. With the critic, it may turn out that there's no advantage ($G - V = 0$) and thus no benefit gained in increasing the actions' probabilities and the algorithm would set the gradients to zero.\n",
        "\n",
        "<br>\n",
        "\n",
        "#### Critic loss\n",
        "\n",
        "Training $V$ to be as close possible to $G$ can be set up as a regression problem with the following loss function:\n",
        "\n",
        "$$L_{critic} = L_{\\delta}(G, V^{\\pi}_{\\theta})$$\n",
        "\n",
        "where $L_{\\delta}$ is the [Huber loss](https://en.wikipedia.org/wiki/Huber_loss), which is less sensitive to outliers in data than squared-error loss.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9EXwbEez6n9m"
      },
      "source": [
        "huber_loss = tf.keras.losses.Huber(reduction=tf.keras.losses.Reduction.SUM)\n",
        "\n",
        "def compute_loss(\n",
        "    action_probs: tf.Tensor,  \n",
        "    values: tf.Tensor,  \n",
        "    returns: tf.Tensor) -> tf.Tensor:\n",
        "  \"\"\"Computes the combined actor-critic loss.\"\"\"\n",
        "\n",
        "  advantage = returns - values\n",
        "\n",
        "  action_log_probs = tf.math.log(action_probs)\n",
        "  actor_loss = -tf.math.reduce_sum(action_log_probs * advantage)\n",
        "\n",
        "  critic_loss = huber_loss(values, returns)\n",
        "\n",
        "  return actor_loss + critic_loss"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HSYkQOmRfV75"
      },
      "source": [
        "### 4. Defining the training step to update parameters\n",
        "\n",
        "All of the steps above are combined into a training step that is run every episode. All steps leading up to the loss function are executed with the `tf.GradientTape` context to enable automatic differentiation.\n",
        "\n",
        "This tutorial uses the Adam optimizer to apply the gradients to the model parameters.\n",
        "\n",
        "The sum of the undiscounted rewards, `episode_reward`, is also computed in this step. This value will be used later on to evaluate if the success criterion is met.\n",
        "\n",
        "The `tf.function` context is applied to the `train_step` function so that it can be compiled into a callable TensorFlow graph, which can lead to 10x speedup in training.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QoccrkF3IFCg"
      },
      "source": [
        "@tf.function\n",
        "def train_step(\n",
        "    initial_state: tf.Tensor, \n",
        "    model: tf.keras.Model, \n",
        "    optimizer: tf.keras.optimizers.Optimizer, \n",
        "    gamma: float, \n",
        "    max_steps_per_episode: int) -> tf.Tensor:\n",
        "  \"\"\"Runs a model training step.\"\"\"\n",
        "\n",
        "  with tf.GradientTape() as tape:\n",
        "\n",
        "    # Run the model for one episode to collect training data\n",
        "    action_probs, values, rewards = run_episode(\n",
        "        initial_state, model, max_steps_per_episode) \n",
        "\n",
        "    # Calculate expected returns\n",
        "    returns = get_expected_return(rewards, gamma)\n",
        "\n",
        "    # Convert training data to appropriate TF tensor shapes\n",
        "    action_probs, values, returns = [\n",
        "        tf.expand_dims(x, 1) for x in [action_probs, values, returns]\n",
        "    ] \n",
        "\n",
        "    # Calculating loss values to update our network\n",
        "    loss = compute_loss(action_probs, values, returns)\n",
        "\n",
        "  # Compute the gradients from the loss\n",
        "  grads = tape.gradient(loss, model.trainable_variables)\n",
        "\n",
        "  # Apply the gradients to the model's parameters\n",
        "  optimizer.apply_gradients(zip(grads, model.trainable_variables))\n",
        "\n",
        "  episode_reward = tf.math.reduce_sum(rewards)\n",
        "\n",
        "  return episode_reward"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HFvZiDoAflGK"
      },
      "source": [
        "### 5. Run the training loop\n",
        "\n",
        "Training is executed by running the training step until either the success criterion or maximum number of episodes is reached.  \n",
        "\n",
        "A running record of episode rewards is kept in a queue. Once 100 trials are reached, the oldest reward is removed at the left (tail) end of the queue and the newest one is added at the head (right). A running sum of the rewards is also maintained for computational efficiency. \n",
        "\n",
        "Depending on your runtime, training can finish in less than a minute."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kbmBxnzLiUJx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d9f10995-e540-4b3b-fba9-4e8d2cf1fced"
      },
      "source": [
        "%%time\n",
        "\n",
        "model = ActorCritic(num_actions, num_hidden_units)\n",
        "optimizer = tf.keras.optimizers.Adam(learning_rate=lr)\n",
        "running_reward = 0\n",
        "episode_history = []\n",
        "running_reward_history = []\n",
        "\n",
        "render_episode_step = 50\n",
        "!rm -r $animation_dir/\n",
        "!mkdir $animation_dir\n",
        "\n",
        "# Keep the last min_episodes_criterion episode rewards.\n",
        "episodes_reward = deque(maxlen=min_episodes_criterion)\n",
        "\n",
        "with tqdm.trange(max_episodes) as t:\n",
        "  for episode in t:\n",
        "    initial_state = tf.constant(env.reset(), dtype=tf.float32)\n",
        "    episode_reward = int(train_step(\n",
        "        initial_state, model, optimizer, gamma, max_steps_per_episode))\n",
        "    \n",
        "    episodes_reward.append(episode_reward)\n",
        "    running_reward = statistics.mean(episodes_reward)\n",
        "  \n",
        "    t.set_description(f'Episode {episode}')\n",
        "    t.set_postfix(\n",
        "        episode_reward=episode_reward, running_reward=running_reward)\n",
        "  \n",
        "    # Render one out of every render_episode_step episodes.\n",
        "    # Store the value of running_reward as well.\n",
        "    if episode % render_episode_step == 0:\n",
        "        image_path = os.path.join(animation_dir, f'{episode:04d}.gif')\n",
        "        render_episode(env, model, max_steps_per_episode, image_path)\n",
        "        running_reward_history.append(running_reward)\n",
        "        episode_history.append(episode)\n",
        "  \n",
        "    if running_reward > reward_threshold and episode >= min_episodes_criterion:\n",
        "        image_path = os.path.join(animation_dir, f'{episode:04d}.gif')\n",
        "        render_episode(env, model, max_steps_per_episode, image_path)\n",
        "        running_reward_history.append(running_reward)\n",
        "        episode_history.append(episode)\n",
        "\n",
        "        break\n",
        "\n",
        "print(f'\\nSolved at episode {episode}: average reward: {running_reward:.2f}!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "rm: cannot remove 'cartpole-v0/': No such file or directory\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Episode 585:   6%|▌         | 585/10000 [01:13<19:41,  7.97it/s, episode_reward=386, running_reward=478]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Solved at episode 585: average reward: 478.35!\n",
            "CPU times: user 1min 34s, sys: 3.86 s, total: 1min 38s\n",
            "Wall time: 1min 13s\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ru8BEwS1EmAv"
      },
      "source": [
        "## Visualization\n",
        "\n",
        "After training, it would be good to visualize how the model performs in the environment. You can run the cells below to generate a GIF animation of one episode run of the model. Note that additional packages need to be installed for OpenAI Gym to render the environment's images correctly in Colab."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 319
        },
        "id": "J8v2Omp91BE1",
        "outputId": "da13a2ca-598a-479e-c894-e1c27c907306"
      },
      "source": [
        "# Plot the history of the reunning rewad against episodes.\n",
        "plt.plot(episode_history, running_reward_history)\n",
        "plt.xlabel(\"Episodes\")\n",
        "plt.ylabel(\"Running reward\")\n",
        "plt.grid()\n",
        "plt.show()\n",
        "\"\"\"\n",
        "Usually this shows a first rise as the model learns to keep the pendulum\n",
        "straight by pushing it to one side, then a dip as the pendulum begins to\n",
        "consistently hit the boundaries of the environment, finally a rise as the\n",
        "model learns to keep the pendulum completely steady and upwards.\n",
        "\"\"\" "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'\\nUsually this shows a first rise as the model learns to keep the pendulum\\nstraight by pushing it to one side, then a dip as the pendulum begins to\\nconsistently hit the boundaries of the environment, finally a rise as the\\nmodel learns to keep the pendulum completely steady and upwards.\\n'"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TLd720SejKmf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 417
        },
        "outputId": "84454c63-1a90-4b7c-a5d2-9343be1babfa"
      },
      "source": [
        "# View the animation of one of the saved episodes.\n",
        "\n",
        "from IPython.core.interactiveshell import InteractiveShell\n",
        "InteractiveShell.ast_node_interactivity = \"all\"\n",
        "\n",
        "# Specify the episode number here.\n",
        "view_episode = \"0500\"\n",
        "\n",
        "with open(os.path.join(animation_dir, f\"{view_episode}.gif\"),'rb') as f:\n",
        "    ipythondisplay.Image(data=f.read(), format='png')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "R0lGODlhWAKQAYIAAAAAAMyZZmZmzJmZzP///wAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAsAAAAAFgCkAEACP8ACQgcSLCgwYMIEypcyLChw4cQI0qcSLGixYsYM2rcyLGjx48gQ4ocSbKkyZMoU6pcybKly5cwY8qcSbOmzZs4c+rcybOnz59AgwodSrSo0aNIkypdyrSp06dQo0qdSrWq1atYs2rdyrWr169gw4odS7as2bNo06pdy7at27dw48qdS7eu3bt48+rdy7ev37+AAwseTLiw4cOIEytezLix48eQI0ueTLmy5cuYM2vezLmz58+gQ4seTbq06dOoU6tezbq169ewY8ueTbu27du4c+vezbu379/AgwsfTry48ePIkytfzry58+fQo0ufTr269evYs2vfzr279+/gw4v/H0++vPnz6NOrX8++vfv38OPLn0+/vv37+PPr38+/v3+ABAQOJFjQ4EGECRUuZNjQ4UOIESVOpFjR4kWMGTVu5NjR40eQIUWOJFnS5EmUKVWuZNnS5UuYMWXOpFnT5k2cOXXu5NnT50+gQYUOJVrU6FGkSZUuZdrU6VOoUaVOpVrV6lWsWbVu5drV61ewYcWOJVvW7Fm0adWuZdvW7Vu4ceXOpVvX7l28efXu5dvX71/AgQUPJlzY8GHEiRUvZtzY8WPIkSVPplzZ8mXMmTVv5tzZ82fQoUWPJl3a9GnUqVWvZt3a9WvYsWXPpl3b9m3cuXXv5t3b92/gwYUPJ17c//hx5MmVL2fe3Plz6NGlT6de3fp17Nm1b+fe3ft38OHFjydf3vx59OnVr2ff3v17+PHlz6df3/59/Pn17+ff3z9AAgIHEixo8CDChAoXMmzo8CHEiBInUqxo8SLGjBo3cuzo8SPIkCJHkixp8iTKlCpXsmzp8iXMmDJn0qxp8ybOnDp38uzp8yfQoEKHEi1q9CjSpEqXMm3q9CnUqFKnUq1q9SrWrFq3cu3q9SvYsGLHki1r9izatGrXsm3r9i3cuHLn0q1r9y7evHr38u3r9y/gwIIHEy5s+DDixIoXM27s+DHkyJInU65s+TLmzJo3c+7s+TPo0KJHky5t+jTq1P+qV7Nu7fo17NiyZ9Oubfs27ty6d/Pu7fs38ODChxMvbvw48uTKlzNv7vw59OjSp1Ovbv069uzat3Pv7v07+PDix5Mvb/48+vTq17Nv7/49/Pjy59Ovb/8+/vz69/Pv7x8gAYEDCRY0eBBhQoULGTZ0+BBiRIkTKVa0eBFjRo0bOXb0+BFkSJEjSZY0eRJlSpUrWbZ0+RJmTJkzada0eRNnTp07efb0+RNoUKFDiRY1ehRpUqVLmTZ1+hRqVKlTqVa1ehVrVq1buXb1+hVsWLFjyZY1exZtWrVr2bZ1+xZuxABz5xKwexdvXr17+fb1+xdwYMGDCRc2fBhxYsWLGTf/dvwYcmTJkylXthwAc2bNBDh39vwZdGjRo0mXNn0adWrVq1m3dv0admzZs2nXtn0bd27du28H8P0bOAHhw4kXN34ceXLly5k3d/4cenTp06lXt34de3bt27l39/4dfPjuAciXN08AfXr169m3d/8efnz58+nXt38ff379+/n39w+QgMCBBAsaPIgwocKFDBs6fAgxosSJFCtavOgwgMaNHAl4/AgypMiRJEuaPIkypcqVLFu6fAkzpsyZNGvavIkzp86dPHvmDAA0qFACRIsaPYo0qdKlTJs6fQo1qtSpVKtavYo1q9atXLt6/Qo2rNixXwOYPYuWgNq1bNu6fQs3/67cuXTr2r2LN6/evXz7+v0LOLDgwYQLGz6MOHHhAIwbOyYAObLkyZQrW76MObPmzZw7e/4MOrTo0aRLmz6NOrXq1axbu369OoDs2bQJ2L6NO7fu3bx7+/4NPLjw4cSLGz+OPLny5cybO38OPbr06dSrRw+APbt2Aty7e/8OPrz48eTLmz+PPr369ezbu38PP778+fTr27+PP7/+/fcD+AcYQODAAAQMHkSYUOFChg0dPoQYUeJEihUtXsSYUeNGjh09fgQZUuRIkiVDBkCZUiUBli1dvoQZU+ZMmjVt3sSZU+dOnj19/gQaVOhQokWNHkWaVOnSowGcPoVKQOpUqv9VrV7FmlXrVq5dvX4FG1bsWLJlzZ5Fm1btWrZt3b6FG7dtALp17RLAm1fvXr59/f4FHFjwYMKFDR9GnFjxYsaNHT+GHFnyZMqVLV+eHEDzZs4EPH8GHVr0aNKlTZ9GnVr1atatXb+GHVv2bNq1bd/GnVv3bt69cwcAHlw4AeLFjR9Hnlz5cubNnT+HHl36dOrVrV/Hnl37du7dvX8HH178+O8BzJ9HT0D9evbt3b+HH1/+fPr17d/Hn1//fv79/QMkIHAgwYIGDyJMqHAhw4YOH0KMKHEixYoWL2LMyDAAx44eCYAMKXIkyZImT6JMqXIly5YuX8KMKXMmzZo2b+L/zKlzJ8+ePn/uDCB0KFECRo8iTap0KdOmTp9CjSp1KtWqVq9izap1K9euXr+CDSt2LNmyYQOgTauWANu2bt/CjSt3Lt26du/izat3L9++fv8CDix4MOHChg8jTqx48eEAjh9DJiB5MuXKli9jzqx5M+fOnj+DDi16NOnSpk+jTq16NevWrl/Djt06AO3atgngzq17N+/evn8DDy58OPHixo8jT658OfPmzp9Djy59OvXq1q9PD6B9O3cC3r+DDy9+PPny5s+jT69+Pfv27t/Djy9/Pv369u/jz69/P//++QEGEDiQIAGDBxEmVLiQYUOHDyFGlDiRYkWLFzFm1LiR/2NHjx9BhhQ5kmTJkAFQplRJgGVLly9hxpQ5k2ZNmzdx5tS5k2dPnz+BBhU6lGhRo0eRJlW69GgAp0+hEpA6lWpVq1exZtW6lWtXr1/BhhU7lmxZs2fRplW7lm1bt2/hxm0bgG5duwTw5tW7l29fv38BBxY8mHBhw4cRJ1a8mHFjx48hR5Y8mXJly5cnB9C8mTMBz59BhxY9mnRp06dRp1a9mnVr169hx5Y9m3Zt27dx59a9m3fv3AGABxdOgHhx48eRJ1e+nHlz58+hR5c+nXp169exZ9e+nXt379/Bhxc//nsA8+fRE1C/nn179+/hx5c/n359+/fx59e/n39///8ACQgcSLCgwYMIEypcyLChw4cQI0qcSLGixYsYMzIMwLGjRwIgQ4ocSbKkyZMoU6pcybKly5cwY8qcSbOmzZs4c+rcybOnz587AwgdSpSA0aNIkypdyrSp06dQo0qdSrWq1atYs2rdyrWr169gw4odS7Zs2ABo06olwLat27dw48qdS7eu3bt48+rdy7ev37+AAwseTLiw4cOIEytefDiA48eQCUieTLmy5cuYM2vezLmz58+gQ4seTbq06dOoU6tezbq169ewY7cOQLu2bQK4c+vezbu379/AgwsfTry48ePIkytfzry58+fQo0ufTr269evTA2jfzp2A9+/gw4v/H0++vPnz6NOrX8++vfv38OPLn0+/vv37+PPr38+/f36AAQQOJEjA4EGECRUuZNjQ4UOIESVOpFjR4kWMGTVu5NjR40eQIUWOJFkyZACUKVUSYNnS5UuYMWXOpFnT5k2cOXXu5NnT50+gQYUOJVrU6FGkSZUuPRrA6VOoBKROpVrV6lWsWbVu5drV61ewYcWOJVvW7Fm0adWuZdvW7Vu4cdsGoFvXLgG8efXu5dvX71/AgQUPJlzY8GHEiRUvZtzY8WPIkSVPplzZ8uXJATRv5kzA82fQoUWPJl3a9GnUqVWvZt3a9WvYsWXPpl3b9m3cuXXv5t07dwDgwYUTIF7c//hx5MmVL2fe3Plz6NGlT6de3fp17Nm1b+fe3ft38OHFj/8ewPx59ATUr2ff3v17+PHlz6df3/59/Pn17+ff3z9AAgIHEixo8CDChAoXMmzo8CHEiBInUqxo8SLGjAwDcOzokQDIkCJHkixp8iTKlCpXsmzp8iXMmDJn0qxp8ybOnDp38uzp8+fOAEKHEiVg9CjSpEqXMm3q9CnUqFKnUq1q9SrWrFq3cu3q9SvYsGLHki0bNgDatGoJsG3r9i3cuHLn0q1r9y7evHr38u3r9y/gwIIHEy5s+DDixIoXHw7g+DFkApInU65s+TLmzJo3c+7s+TPo0KJHky5t+jTq1P+qV7Nu7fo17NitA9CubZsA7ty6d/Pu7fs38ODChxMvbvw48uTKlzNv7vw59OjSp1Ovbv369ADat3Mn4P07+PDix5Mvb/48+vTq17Nv7/49/Pjy59Ovb/8+/vz69/Pvnx9gAIEDCRIweBBhQoULGTZ0+BBiRIkTKVa0eBFjRo0bOXb0+BFkSJEjSZYMGQBlSpUEWLZ0+RJmTJkzada0eRNnTp07efb0+RNoUKFDiRY1ehRpUqVLjwZw+hQqAalTqVa1ehVrVq1buXb1+hVsWLFjyZY1exZtWrVr2bZ1+xZu3LYB6Na1SwBvXr17+fb1+xdwYMGDCRc2fBhxYsWLGTf/dvwYcmTJkylXtnx5cgDNmzkT8PwZdGjRo0mXNn0adWrVq1m3dv0admzZs2nXtn0bd27du3n3zh0AeHDhBIgXN34ceXLly5k3d/4cenTp06lXt34de3bt27l39/4dfHjx478HMH8ePQH169m3d/8efnz58+nXt38ff379+/n39w+QgMCBBAsaPIgwocKFDBs6fAgxosSJFCtavIgxI8MAHDt6JAAypMiRJEuaPIkypcqVLFu6fAkzpsyZNGvavIkzp86dPHv6/LkzgNChRAkYPYo0qdKlTJs6fQo1qtSpVKtavYo1q9atXLt6/Qo2rNixZMuGDYA2rVoCbNu6fQs3/67cuXTr2r2LN6/evXz7+v0LOLDgwYQLGz6MOLHixYcDOH4MmYDkyZQrW76MObPmzZw7e/4MOrTo0aRLmz6NOrXq1axbu34NO3brALRr2yaAO7fu3bx7+/4NPLjw4cSLGz+OPLny5cybO38OPbr06dSrW78+PYD27dwJeP8OPrz48eTLmz+PPr369ezbu38PP778+fTr27+PP7/+/fz75wcYQOBAggQMHkSYUOFChg0dPoQYUeJEihUtXsSYUeNGjh09fgQZUuRIkiVDBkCZUiUBli1dvoQZU+ZMmjVt3sSZU+dOnj19/gQaVOhQokWNHkWaVOnSowGcPoVKQOpUqv9VrV7FmlXrVq5dvX4FG1bsWLJlzZ5Fm1btWrZt3b6FG7dtALp17RLAm1fvXr59/f4FHFjwYMKFDR9GnFjxYsaNHT+GHFnyZMqVLV+eHEDzZs4EPH8GHVr0aNKlTZ9GnVr1atatXb+GHVv2bNq1bd/GnVv3bt69cwcAHlw4AeLFjR9Hnlz5cubNnT+HHl36dOrVrV/Hnl37du7dvX8HH178+O8BzJ9HT0D9evbt3b+HH1/+fPr17d/Hn1//fv79/QMkIHAgwYIGDyJMqHAhw4YOH0KMKHEixYoWL2LMyDAAx44eCYAMKXIkyZImT6JMqXIly5YuX8KMKXMmzZo2b+L/zKlzJ8+ePn/uDCB0KFECRo8iTap0KdOmTp9CjSp1KtWqVq9izap1K9euXr+CDSt2LNmyYQOgTauWANu2bt/CjSt3Lt26du/izat3L9++fv8CDix4MOHChg8jTqx48eEAjh9DJiB5MuXKli9jzqx5M+fOnj+DDi16NOnSpk+jTq16NevWrl/Djt06AO3atgngzq17N+/evn8DDy58OPHixo8jT658OfPmzp9Djy59OvXq1q9PD6B9O3cC3r+DDy9+PPny5s+jT69+Pfv27t/Djy9/Pv369u/jz69/P//++QEGEDiQIAGDBxEmVLiQYUOHDyFGlDiRYkWLFzFm1LiR/2NHjx9BhhQ5kmTJkAFQplRJgGVLly9hxpQ5k2ZNmzdx5tS5k2dPnz+BBhU6lGhRo0eRJlW69GgAp0+hEpA6lWpVq1exZtW6lWtXr1/BhhU7lmxZs2fRplW7lm1bt2/hxm0bgG5duwTw5tW7l29fv38BBxY8mHBhw4cRJ1a8mHFjx48hR5Y8mXJly5cnB9C8mTMBz59BhxY9mnRp06dRp1a9mnVr169hx5Y9m3Zt27dx59a9m3dv3AGABxdOgHhx48eRJ1e+nHlz58+hR5c+nXp169exZ9e+nXt379/Bhxc//nsA8+fRE1C/nn179+/hx5c/n359+/fx59e/n39///8ACQgcSLCgwYMIEypcyLChw4cQI0qcSLGixYsYMzIMwLGjRwIgQ4ocSbKkyZMoU6pcybKly5cwY8qcSbOmzZs4c+rcybOnz587AwgdSpSA0aNIkypdyrSp06dQo0qdSrWq1atYs2rdyrWr169gw4odS7Zs2ABo06olwLat27dw48qdS7eu3bt48+rdy7ev37+AAwseTLiw4cOIEytefDiA48eQCUieTLmy5cuYM2vezLmz58+gQ4seTbq06dOoU6tezbq169ewY7cOQLu2bQK4c+vezbu379/AgwsfTry48ePIkytfzry58+fQo0ufTr269evTA2jfzp2A9+/gw4v/H0++vPnz6NOrX8++vfv38OPLn0+/vv37+PPr38+/f36AAQQOJEjA4EGECRUuZNjQ4UOIESVOpFjR4kWMGTVu5NjR40eQIUWOJFkyZACUKVUSYNnS5UuYMWXOpFnT5k2cOXXu5NnT50+gQYUOJVrU6FGkSZUuPRrA6VOoBKROpVrV6lWsWbVu5drV61ewYcWOJVvW7Fm0adWuZdvW7Vu4cdsGoFvXLgG8efXu5dvX71/AgQUPJlzY8GHEiRUvZtzY8WPIkSVPplzZ8uXJATRv5kzA82fQoUWPJl3a9GnUqVWvZt3a9WvYsWXPpl3b9m3cuXXv5t07dwDgwYUTIF7c//hx5MmVL2fe3Plz6NGlT6de3fp17Nm1b+fe3ft38OHFj/8ewPx59ATUr2ff3v17+PHlz6df3/59/Pn17+ff3z9AAgIHEixo8CDChAoXMmzo8CHEiBInUqxo8SLGjAwDcOzokQDIkCJHkixp8iTKlCpXsmzp8iXMmDJn0qxp8ybOnDp38uzp8+fOAEKHEiVg9CjSpEqXMm3q9CnUqFKnUq1q9SrWrFq3cu3q9SvYsGLHki0bNgDatGoJsG3r9i3cuHLn0q1r9y7evHr38u3r9y/gwIIHEy5s+DDixIoXHw7g+DFkApInU65s+TLmzJo3c+7s+TPo0KJHky5t+jTq1P+qV7Nu7fo17NitA9CubZsA7ty6d/Pu7fs38ODChxMvbvw48uTKlzNv7vw59OjSp1Ovbv369ADat3Mn4P07+PDix5Mvb/48+vTq17Nv7/49/Pjy59Ovb/8+/vz69/Pvnx9gAIEDCRIweBBhQoULGTZ0+BBiRIkTKVa0eBFjRo0bOXb0+BFkSJEjSZYMGQBlSpUEWLZ0+RJmTJkzada0eRNnTp07efb0+RNoUKFDiRY1ehRpUqVLjwZw+hQqAalTqVa1ehVrVq1buXb1+hVsWLFjyZY1exZtWrVr2bZ1+xZu3LYB6Na1SwBvXr17+fb1+xdwYMGDCRc2fBhxYsWLGTf/dvwYcmTJkylXtnx5cgDNmzkT8PwZdGjRo0mXNn0adWrVq1m3dv0admzZs2nXtn0bd27du3n3zh0AeHDhBIgXN34ceXLly5k3d/4cenTp06lXt34de3bt27l39/4dfHjx478HMH8ePQH169m3d/8efnz58+nXt38ff379+/n39w+QgMCBBAsaPIgwocKFDBs6fAgxosSJFCtavIgxI8MAHDt6JAAypMiRJEuaPIkypcqVLFu6fAkzpsyZNGvavIkzp86dPHv6/LkzgNChRAkYPYo0qdKlTJs6fQo1qtSpVKtavYo1q9atXLt6/Qo2rNixZMuGDYA2rVoCbNu6fQs3/67cuXTr2r2LN6/evXz7+v0LOLDgwYQLGz6MOLHixYcDOH4MmYDkyZQrW76MObPmzZw7e/4MOrTo0aRLmz6NOrXq1axbu34NO3brALRr2yaAO7fu3bx7+/4NPLjw4cSLGz+OPLny5cybO38OPbr06dSrW7/+G4D27dy7dw8APrx4AOTLmz9/noD69ezbu38PP778+fTr27+PP7/+/fz7+wdIQOBAggUNHkSYUOFChg0dPoQYUeJEihUtXqwIQONGjh07BgAZUiQAkiVNnjxJQOVKli1dvoQZU+ZMmjVt3sSZU+dOnj19/gQaVOhQokWNHkXqE8BSpk2dOg0QVepUAP9VrV7FipXAVq5dvX4FG1bsWLJlzZ5Fm1btWrZt3b6FG1fuXLp17d7Fm/ctAL59/f79GyDAAAEDBAwQECAAAMaNHT9+TEDyZMqVLV/GnFnzZs6dPX8GHVr0aNKlTZ9GnVr1atatXb+GbRrAbNq1bdsOIGCAgAECBggYEADAcOLFjRsnkFz5cubNnT+HHl36dOrVrV/Hnl37du7dvX8HH178ePLlzZ/vDkD9evbt2w8QMEDAAAEDBAwQAED/fv79+wMkIHAgwYIGDyJMqHAhw4YOH0KMKHEixYoWL2LMqHEjx44eP4K0CGAkyZImTQoYIGCAgAECBggYAGAmzZo2bRL/yKlzJ8+ePn8CDSp0KNGiRo8iTap0KdOmTp9CjSp1KtWqVq82BaB1K9euXQcIGCBggIABAgYIAKB2Ldu2bQnAjSt3Lt26du/izat3L9++fv8CDix4MOHChg8jTqx4MePGjgkDiCx5MmXKAgYIGCBggIABAgYACC16NGnSBE6jTq16NevWrl/Dji17Nu3atm/jzq17N+/evn8DDy58OPHiuwEgT658+fIBAgYIGCBggIABAgBgz659+3YC3r+DDy9+PPny5s+jT69+Pfv27t/Djy9/Pv369u/jz69/P3/5AAACEDiQYEGCAQYIGCBggIABAgIAkDiRYsWKBDBm1LiR/2NHjx9BhhQ5kmRJkydRplS5kmVLly9hxpQ5k2ZNmywB5NS5kyfPAAEEDBAwQMCAAAEAJFW6lClTAk+hRpU6lWpVq1exZtW6lWtXr1/BhhU7lmxZs2fRplW7lm3bsQDgxpU7l67cAHfvAtC7l2/fvgQABxY8mHBhw4cRJ1a8mHFjx48hR5Y8mXJly5cxZ9a8mXNnz5QBhBY9mnRp06dRkyawmnVr169hx5Y9m3Zt27dx59a9m3dv37+BBxc+nHhx48eRJ/8NgHlz58+hR5c+/TkB69exZ9e+nXt379/Bhxc/nnx58+fRp1dvHkB79+/hx5c/n359+/fx59e/n39///8AAQgcSLCgwYMIEypcyLChw4cQI0qcSLGixYsYM2rcyJEggY8gQ4ocSbKkyZMoU6pcybKly5cwY8qcSRMkgJs4c+rcybOnT50EggodSrSo0aNIkypdyrSp06dQo0qdSrWq1atYs2rdyrWr169VAYgdS7as2bNo05YlwLat27dw48qdS7eu3bt48+rdy7ev37+AAwseTLiw4cOIEysGDKCx48eQI0ueTBkygcuYM2vezLmz58+gQ4seTbq06dOoU6tezbq169ewY8ueTbv2agC4c+vezbu379+7CQgfTry48ePIkytfzry58+fQo0ufTr269evYs2vfzr279+/grQP/GE++vPnz6NOrN0+gvfv38OPLn0+/vv37+PPr38+/v3+ABAQOJFjQ4EGECRUuZNjQ4UOIESVOpFjR4kWMGTUmBNDR40eQIUWOJAmSwEmUKVWuZNnS5UuYMWXOpFnT5k2cOXXu5NnT50+gQYUOJVp0JwCkSZUuZdrU6dOlBKROpVrV6lWsWbVu5drV61ewYcWOJVvW7Fm0adWuZdvW7Vu4ZgHMpVvX7l28efXaJdDX71/AgQUPJlzY8GHEiRUvZtzY8WPIkSVPplzZ8mXMmTVvjgzA82fQoUWPJl06NAHUqVWvZt3a9WvYsWXPpl3b9m3cuXXv5t3b92/gwYUPJ17c/zhvAMmVL2fe3Plz6MwJTKde3fp17Nm1b+fe3ft38OHFjydf3vx59OnVr2ff3v17+PHPA6Bf3/59/Pn1779PwD9AAgIHEixo8CDChAoXMmzo8CHEiBInUqxo8SLGjBo3cuzo8SPIiQBGkixp8iTKlCpNEmjp8iXMmDJn0qxp8ybOnDp38uzp8yfQoEKHEi1q9CjSpEqXBgXg9CnUqFKnUq0alQDWrFq3cu3q9SvYsGLHki1r9izatGrXsm3r9i3cuHLn0q1rly2AvHr38u3r9y9gvgQGEy5s+DDixIoXM27s+DHkyJInU65s+TLmzJo3c+7s+TPo0KJHky5t+jTq1P+qV7Nu7fo17NiyZ9Oubfs27ty6d/Pu7fs38ODChxMvbvw48uTKlzNv7vw59OjSp1Ovbv069uzat3Pv7v07+PDix5Mvb/48+vTq17Nv7/49/Pjy59Ovb/8+/vz69/Pv7x8gAYEDCRY0eBBhQoULGTZ0+BBiRIkTKVa0eBFjRo0bOXb0+BFkSJEjSZY0eRJlSpUrWbZ0+RJmTJkzada0eRNnTp07efb0+RNoUKFDiRY1ehRpUqVLmTZ1+hRqVKlTqVa1ehVrVq1buXb1+hVsWLFjyZY1exZtWrVr2bZ1+xZuXLlz6da1exdvXr17+fb1+xdwYMGDCRc2fBhxYsWLGTf/dvwYcmTJkylXtnwZc2bNmzl39vwZdGjRo0mXNn0adWrVq1m3dv0admzZs2nXtn0bd27du3n39v0beHDhw4kXN34ceXLly5k3d/4cenTp06lXt34de3bt27l39/4dfHjx48mXN38efXr169m3d/8efnz58+nXt38ff379+/n39w+QgMCBBAsaPIgwocKFDBs6fAgxosSJFCtavIgxo8aNHDt6/AgypMiRJEuaPIkypcqVLFu6fAkzpsyZNGvavIkzp86dPHv6/Ak0qNChRIsaPYo0qdKlTJs6fQo1qtSpVKtavYo1q9atXLt6/Qo2rNixZMuaPYs2rdq1bNu6fQs3Kq7cuXTr2r2LN6/evXz7+v0LOLDgwYQLGz6MOLHixYwbO34MObLkyYUDAgAh/wtORVRTQ0FQRTIuMAMBAAAALBUBrAA0AI8AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIHEiwoEECARImJMCwocOHECNKnMgwgMWLGAlo3Mixo8ePID0GGEmyJIGTKFOqXMmy5coAMGPKJECzps2bOHPqxBmgp8+fBIIKHUq0qNGjRQMoXcqUgNOnUKNKnUpVaoCrWLMS2Mq1q9evYMN+DUC2rFkCaNOqXcu2rVu2AeLKnUugrt27ePPq3Zs3gN+/gAkIHky4sOHDiA0HWMy4MYHHkCNLnky58uQAmDNrJsC5s+fPoEOLBh2gtOnTBFKrXs26tevXrQPInk2bgO3buHPr3s1bd4DfwIMTGE68uPHjyJMfD8C8uXMC0KNLn069unXqAbJr306gu/fv4MOL/x8fPoD58+gJqF/Pvr379/DdB5hPvz6B+/jz69/Pv/9+gAEEDiRIwOBBhAkVLmSoMMBDiBEJTKRY0eJFjBkvBuDY0SMBkCFFjiRZ0iTJAClVriTQ0uVLmDFlzowZwOZNnAR07uTZ0+dPoD4DDCValMBRpEmVLmXadGkAqFGlEqBa1epVrFm1Yg3Q1etXAmHFjiVb1uzZsgHUrmVLwO1buHHlzqUrN8BdvHkJ7OXb1+9fwIH/BiBc2DABxIkVL2bc2DHjAJElTyZQ2fJlzJk1b84cwPNn0AREjyZd2vRp1KYDrGbdmsBr2LFlz6Zde3YA3Ll1E+Dd2/dv4MGFAw9Q3P/4cQLJlS9n3tz58+YBpE+nTsD6dezZtW/nrj3Ad/DhCYwnX978efTpzwdg3949Afjx5c+nX98+/QD59e8n0N8/QAICBxIsaPAgwgAKFzIk4PAhxIgSJ1KUGOAixowENnLs6PEjyJAfA5AsaZIAypQqV7Js6ZJlgJgyZxKoafMmzpw6d+YM4PMnUAJChxItavQoUqMBljJtSuAp1KhSp1KtOjUA1qxaCXDt6vUr2LBiwQYoa/YsgbRq17Jt6/Zt2wBy59IlYPcu3rx69/LVG+Av4MAEBhMubPgw4sSHAzBu7JgA5MiSJ1OubJlygMyaNxPo7Pkz6NCiR4cOYPo0agL/qlezbu36NWzXAWbTrk3gNu7cunfz7r07APDgwgkQL278OPLkyo8HaO78OYHo0qdTr279evUA2rdzJ+D9O/jw4seTFx/gPPr0BNazb+/+Pfz47wPQr2+fAP78+vfz7+8fIAGBAwMUNHiQQEKFCxk2dPiwYQCJEykSsHgRY0aNGzlqDPARZEgCI0mWNHkSZcqTAVi2dEkAZkyZM2nWtEkzQE6dOwn09PkTaFChQ4MGMHoUKQGlS5k2dfoUqtMAU6lWJXAVa1atW7l23RoAbFixBMiWNXsWbVq1aAO0dfuWQFy5c+nWtXu3bgC9e/kS8PsXcGDBgwkLDnAYcWICixk3/3b8GHLkxwEoV7ZMAHNmzZs5d/bMOUBo0aMJlDZ9GnVq1atTB3D9GjYB2bNp17Z9G7ftALt59ybwG3hw4cOJFx8eAHly5QSYN3f+HHp06dADVLd+nUB27du5d/f+vXsA8ePJEzB/Hn169evZqw/wHn58AvPp17d/H3/++wH49/cPkIDAgQQLGjyI0GCAhQwbEngIMaLEiRQrTgyAMaNGAhw7evwIMqRIkAFKmjxJIKXKlSxbunzZMoDMmTQJ2LyJM6fOnTx1BvgJNCiBoUSLGj2KNOnRAEybOiUANarUqVSrWqUaIKvWrQS6ev0KNqzYsWEDmD2LloDatWzbun0L1/9tgLl06xK4izev3r18++4NADiwYAKECxs+jDixYsQBGjt+TCCy5MmUK1u+XDmA5s2cCXj+DDq06NGkRQc4jTo1gdWsW7t+DTv26wC0a9smgDu37t28e/vmHSC48OEEihs/jjy58uXJAzh/Dp2A9OnUq1u/jt16gO3cuxP4Dj68+PHky48PgD69egLs27t/Dz++fPgB6tu/TyC//v38+/sHSEDgQIIEAxxEmJDAQoYNHT6EGPFhAIoVLRLAmFHjRo4dPXIMEFLkSAIlTZ5EmVLlypQBXL6ESUDmTJo1bd7EaTPATp49CfwEGlToUKJFhwZAmlQpAaZNnT6FGlUq1AD/Va1eJZBV61auXb1+7RpA7FiyBMyeRZtW7Vq2agO8hRuXwFy6de3exZv3bgC+ff0SABxY8GDChQ0TDpBY8WICjR0/hhxZ8uTIASxfxkxA82bOnT1/Bu05wGjSpQmcRp1a9WrWrVcHgB1bNgHatW3fxp1bN+4AvX3/JhBc+HDixY0fLx5A+XLmBJw/hx5dOgDq1a1fxx5A+3buALx/Bx8ePAECAMyfR59efQD27d0DgB9f/nz5BAgAwJ9f/37+AfwDDCBwYAAABg8iTIiQAAEADh9CjBgxQIABAgYIGCAgQAAAHj+CDBmSAAEAJk+iTJkygIABAgYIGCBgQAAANm/i/8yZkwABAD5/Ag0aNMAAAQMEDBAwQMAAAE6fQo0alQABAFavYs2aNYCAAQIGCBggYIAAAGbPok2blgABAG7fwo0bd4CAAQIGCBggYIAAAH7/Ag4cmAABAIYPI06cOMAAAQMEDBAwQMAAAJYvY86cmQABAJ4/gw4dOoCAAQIGCBggYIAAAK5fw44dmwABALZv486dO8AAAQMEDBAwQEAAAMaPI0+enAABAM6fQ48ePUCAAQIGCBggIEAAAN6/gw8fngABAObPo0+vHn2A9u0BwI8vf/58AgQA4M+vfz///v4BAhA4kCBBAgQAJFS4kGFDhw8hMiRAAEBFixcxZtS4kbpjR48fQXokQABASZMnUaZUuZIlSgIEAMSUOZNmTZs3cdIkQABAT58/gQYVOpQoUAIEACRVupRpU6dPoTIlQABAVatXsWbVupUrVgIEAIQVO5ZsWbNn0ZIlQABAW7dv4caVO5cuXAIEAOTVu5dvX79/AfMlQABAYcOHESdWvJgxYgIEAESWPJlyZcuXMVMmQABAZ8+fQYcWPZo0aAIEAKRWvZp1a9evYbMmQABAbdu3cefWvZs3bgIEAgIAIf8LTkVUU0NBUEUyLjADAQAAACwVAawANACPAIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAI/wAJCBxIsKBBgwESBiDAsKHDhxAjSoQYoKLFiwQyatzIsaPHjx0DiBxJkoDJkyhTqlzJUmWAlzBjEphJs6bNmzhz3gzAs6dPAkCDCh1KtKhRogGSKl1KoKnTp1CjSp0aNYDVq1gJaN3KtavXr2C9BhhLtiyBs2jTql3Ltu3aAHDjyiVAt67du3jz6sUboK/fvwQCCx5MuLDhw4UDKF7MmIDjx5AjS55MWXKAy5gzE9jMubPnz6BDfw5AurRpAqhTq17NurVr1gFiy55NoLbt27hz696dO4Dv38AJCB9OvLjx48iNB1jOvDmB59CjS59Ovfr0ANizayfAvbv37+DDi/8HH6C8+fME0qtfz769+/ftA8ifT5+A/fv48+vfz19/AIABBA4cSMDgQYQJFS5kqDDAQ4gRCUykWNHiRYwZLwbg2NEjAZAhRY4kWdIkyQApVa4k0NLlS5gxZc6MGcDmTZwEdO7k2dPnT6A+AwwlWpTAUaRJlS5l2nRpAKhRpRKgWtXqVaxZtWIN0NXrVwJhxY4lW9bs2bIB1K5lS8DtW7hx5c6lKzfAXbx5Cezl29fvX8CB/wYgXNgwAcSJFS9m3Ngx4wCRJU8mUNnyZcyZNW/OHMDzZ9AERI8mXdr0adSmA6xm3ZrAa9ixZc+mXXt2ANy5dRPg3dv3b+DBhQMPUNz/+HECyZUvZ97c+fPmAaRPp07A+nXs2bVv5649wHfw4QmMJ1/e/Hn06c8HYN/ePQH48eXPp1/fPv0A+fXvJ9DfP0ACAgcSLGjwIMIAChcyJODwIcSIEidSlBjgIsaMBDZy7OjxI8iQHwOQLGmSAMqUKleybOmSZYCYMmcSqGnzJs6cOnfmDODzJ1ACQocSLWr0KFKjAZYybUrgKdSoUqdSrTo1ANasWglw7er1K9iwYsEGKGv2LIG0ateybev2bdsAcufSJWD3Lt68evfy1RvgL+DABAYTLmz4MOLEhwMwbuyYAOTIkidTrmyZcoDMmjcT6Oz5M+jQokeHDmD6NGoC/6pXs27t+jVs1wFm065N4Dbu3Lp38+69OwDw4MIJEC9u/Djy5MqRB2ju/DmB6NKnU69u/Xr1ANq3cyfg/Tv48OLHkxcf4Dz69ATWs2/v/j38+O8D0K9vnwD+/Pr38+/vHyABgQMDFDR4kEBChQsZNnT4sGEAiRMpErB4EWNGjRs5agzwEWRIAiNJljR5EmXKkwFYtnRJAGZMmTNp1rRJM0BOnTsJ9PT5E2hQoUODBjB6FCkBpUuZNnX6FKrTAFOpViVwFWtWrVu5dt0aAGxYsQTIljV7Fm1atWgDtHX7lkBcuXPp1rV7t24AvXv5EvD7F3BgwYMJCw5wGHFiAosZN/92/Bhy5McBKFe2TABzZs2bOXf2zDlAaNGjCZQ2fRp1atWrUwdw/Ro2Admzade2fRu37QC7efcm8Bt4cOHDiRcfHgB5cuUEmDd3/hx6dOnQA1S3fp1Adu3buXf3/r17APHjyRMwfx59evXr2asP8B5+fALz6de3fx9//vsB+Pf3D5CAwIEECxo8iNBggIUMGxJ4CDGixIkUK1IMgDGjRgIcO3r8CDKkSJABSpo8SSClypUsW7p82TKAzJk0Cdi8iTOnzp08dQb4CTQogaFEixo9ijTp0QBMmzolADWq1KlUq1qlGiCr1q0Eunr9Cjas2LFhA5g9i5aA2rVs27p9C9f/bYC5dOsSuIs3r969fPvuDQA4sGAChAsbPow4sWLEARo7fkwgsuTJlCtbvlw5gObNnAl4/gw6tOjRpEUHOI06NYHVrFu7fg079usAtGvbJoA7t+7dvHv75h0guPDhBIobP448ufLlyQM4fw6dgPTp1Ktbv47deoDt3LsT+A4+vPjx5MuPD4A+vXoC7Nu7fw8/vnz4Aerbv08gv/79/Pv7B0hA4ECCBAMcRJiQwEKGDR0+hBjxYQCKFS0SwJhR40aOHT1yDBBS5EgCJU2eRJlS5cqUAVy+hElA5kyaNW3exGkzwE6ePQn8BBpU6FCiRYcGQJpUKQGmTZ0+hRpVKtQA/1WtXiWQVetWrl29fu0aQOxYsgTMnkWbVu1atmoDvIUbl8BcunXt3sWb924Avn39EgAcWPBgwoUNEw6QWPFiAo0dP4YcWfLkyAEsX8ZMQPNmzp09fwbtOcBo0qUJnEadWvVq1q1XB4AdWzYB2rVt38adWzfuAL19/yYQXPhw4sWNHy8eQPly5gScP4ceXToBANWtX8eOPcB27t0BfAcfXrx4AgQAnEefXr36AO3dvwcQX/58+vQJEACQX/9+/vwDAAwgcOBAAAYPIkyYkAABAA4fQowYMUCAAQIGCBggIEAAAB4/ggwZkgABACZPokyZMoCAAQIGCBggYEAAADZv4v/MmZMAAQA+fwINGnSAgAECBggYIGBAAABOn0KNGpUAAQBWr2LNmlXAAAEDBAwQMEDAAABmz6JNm5YAAQBu38KNG3eAgAECBggYIGCAAAB+/wIOHJgAAQCGDyNOnFjAAAEDBAwQMEDAAACWL2POnJkAAQCeP4MOHXqAgAECBggYIGBAAACuX8OOHZsAAQC2b+POnTvAAAEDBAwQMEBAAADGjyNPnpwAAQDOn0OPHj1AAAEDBAwQMCBAAADev4MPH54AAQDmz6NPnz4Ae/YA3sOPL39+fAIEAODPr38///7+AQIQOJAgQQIEACRUuJBhQ4cPIUaUOJGiRAIEAGTUuJG3Y0ePH0FyJEAAQEmTJ1GmVLmSJUoCBADElDmTZk2bN3HSJEAAQE+fP4EGFTqUKFACBAAkVbqUaVOnT6EyJUAAQFWrV7Fm1bqVK1YCBACEFTuWbFmzZ9GSJUAAQFu3b+HGlTuXLlwCBADk1buXb1+/fwHzJUAAQGHDhxEnVryYMWICBABEljyZcmXLlzFTJkAAQGfPn0GHFj2aNGgCBACkVr2adWvXr2GzJkAAQG3bt3Hn1r2bN+6AACH/C05FVFNDQVBFMi4wAwEAAAAsFgGsADMAjwCCAAAAzJlmZmbMmZnM////AAAAAAAAAAAACP8ACQgcSLCgwYMIEypcWDCAw4cQCUicSLGixYsYKwbYyLEjgY8gQ4ocSbKkyAAoU6okwLKly5cwY8p8GaCmzZsEcurcybOnz588AwgdSpSA0aNIkypdyjRpgKdQoxKYSrWq1atYs1oNwLWrVwJgw4odS7as2bEB0qpdS6Ct27dw48qdCzeA3bt4Cejdy7ev37+A+wYYTLgwgcOIEytezLix4gCQI0smQLmy5cuYM2u+HKCz588EQoseTbq06dOkA6hezZqA69ewY8ueTTt2gNu4cxPYzbu379/Ag/sOQLy4cQLIkytfzry58+UBokufTqC69evYs2vfjj2A9+/gCYj/H0++vPnz6MsHWM++PYH38OPLn0+/vvwA+PPrJ8C/v3+ABAQOJFjQ4MGBARQuZEjA4UOIESVOpBgxwEWMGQls5NjR40eQIT0GIFnSJAGUKVWuZNnS5coAMWXOJFDT5k2cOXXuxBnA50+gBIQOJVrU6FGkRQMsZdqUwFOoUaVOpVpVagCsWbUS4NrV61ewYcV+DVDW7FkCadWuZdvW7Vu2AeTOpUvA7l28efXu5Zs3wF/AgQkMJlzY8GHEiQ0HYNzYMQHIkSVPplzZ8uQAmTVvJtDZ82fQoUWPBh3A9GnUBFSvZt3a9WvYrQPMpl2bwG3cuXXv5t1bdwDgwYUTIF7c//hx5MmVHw/Q3PlzAtGlT6de3fp16gG0b+dOwPt38OHFjycfPsB59OkJrGff3v17+PHdB6Bf3z4B/Pn17+ff3z9AAgIFBiho8CCBhAoXMmzo8CHDABInUiRg8SLGjBo3cswY4CPIkARGkixp8iTKlCYDsGzpkgDMmDJn0qxpc2aAnDp3Eujp8yfQoEKHAg1g9ChSAkqXMm3q9CnUpgGmUq1K4CrWrFq3cu2qNQDYsGIJkC1r9izatGrPBmjr9i2BuHLn0q1r9y7dAHr38iXg9y/gwIIHEw4c4DDixAQWM27s+DHkyI4DUK5smQDmzJo3c+7seXOA0KJHEyht+jTq1P+qV6MO4Po1bAKyZ9Oubfs27toBdvPuTeA38ODChxMvLjwA8uTKCTBv7vw59OjSnweobv06gezat3Pv7v079wDix5MnYP48+vTq17NPH+A9/PgE5tOvb/8+/vz2A/Dv7x8gAYEDCRY0eBBhwQALGTYk8BBiRIkTKVaUGABjRo0EOHb0+BFkSJEfA5Q0eZJASpUrWbZ0+ZJlAJkzaRKweRNnTp07eeYM8BNoUAJDiRY1ehRpUqMBmDZ1SgBqVKlTqVa1OjVAVq1bCXT1+hVsWLFjwQYwexYtAbVr2bZ1+xZu2wBz6dYlcBdvXr17+fbVGwBwYMEECBc2fBhxYsWHAzT/dvyYQGTJkylXtnyZcgDNmzkT8PwZdGjRo0mHDnAadWoCq1m3dv0admzXAWjXtk0Ad27du3n39r07QHDhwwkUN34ceXLly5EHcP4cOgHp06lXt34de/UA27l3J/AdfHjx48mXFx8AfXr1BNi3d/8efnz57wPUt3+fQH79+/n39w+QgMCBBAcGOIgwIYGFDBs6fAgxosMAFCtaJIAxo8aNHDt63BggpMiRBEqaPIkypcqVKAO4fAmTgMyZNGvavImzZoCdPHsS+Ak0qNChRIsKDYA0qVICTJs6fQo1qtSnAapavUogq9atXLt6/co1gNixZAmYPYs2rdq1bNMGeAs3/y6BuXTr2r2LN6/dAHz7+iUAOLDgwYQLGx4cILHixQQaO34MObLkyZADWL6MmYDmzZw7e/4MunOA0aRLEziNOrXq1axbqw4AO7ZsArRr276NO7fu2wF6+/5NILjw4cSLGz9OPIDy5cwJOH8OPbr06dSjB7iOPTuB7dy7e/8OPrz3AOTLmyeAPr369ezbu18fIL78+QTq27+PP7/+/fgD+AcYQODAAAQMHkSYUOFChgkDPIQYkcBEihUtXsSY0WIAjh09EgAZUuRIkiVNjgyQUuVKAi1dvoQZU+ZMmAFs3sRJQOdOnj19/gTaM8BQokUJHEWaVOlSpk2VBoAaVSoBqv9VrV7FmlXr1QBdvX4lEFbsWLJlzZ4lG0DtWrYE3L6FG1fuXLpxA9zFm5fAXr59/f4FHNhvAMKFDRNAnFjxYsaNHS8OEFnyZAKVLV/GnFnzZswBPH8GTUD0aNKlTZ9GXTrAatatCbyGHVv2bNq1ZQfAnVs3Ad69ff8GHlz47wDFjR8nkFz5cubNATyHHl269ADVrV8HkF37du7cCQAAH178+PEBzJ9HD0D9evbt2xMAEF/+fPr0A9zHnx/Afv79/QMEIFAgAQAGDyJMmDBAgAECBggYICBAAAAWL2LMmJEAgI4eP4IEGUDAAAEDBAwQMCAAgJYuX8KESQAAzZo2b97/HCBggIABAgYIGCAAANGiRo8eJQBgKdOmTp0KGCBggIABAgYIGABgK9euXr0SACB2LNmyZQcIGCBggIABAgYIACB3Lt26dQkAyKt3L1++AgYIGCBggIABAgYASKx4MWPGBABAjix58uQBAgYIGCBggIABAgCADi169GgCAE6jTq1adYABAgYIGCBggIAAAG7jzq1bNwEAvn8DDx48QAABAwQMEDAgQAAAzp9Djx6dAIDq1q9jxx5gO/fuAL6DDy9ePAEA5s+jT69+Pfv26QkAiC9/Pv369u/jp08AAP/+/gECEDiQYEGDBxEmVLiQYUMCACBGlDiRYkWLFycSALCRk2NHjx9BhhTpkQAAkydRplS5kmXLlAQAxJQ5k2ZNmzdx0iQAgGdPnz+BBhU69CcBAEeRJlW6lGlTp0oJAJA6lWpVq1exZq1KAEBXr1/BhhU7lixYAgDQplW7lm1bt2/XEgAwl25du3fx5tVrlwAAv38BBxY8mHDhwAQAJFa8mHFjx48hMyYAgHJly5cxZ9a8+TKBgAAh/wtORVRTQ0FQRTIuMAMBAAAALBUBrAAzAI8AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIHEiwoMEACAMQWMiwocOHECNKXBigosWLBDJq3Mixo8ePHAOIHEmSgMmTKFOqXMkyZYCXMGMSmEmzps2bOHPaDMCzp08CQIMKHUq0qNGhAZIqXUqgqdOnUKNKnQo1gNWrWAlo3cq1q9evYLsGGEu2LIGzaNOqXcu2rdoAcOPKJUC3rt27ePPqvRugr9+/BAILHky4sOHDhAMoXsyYgOPHkCNLnkw5coDLmDMT2My5s+fPoEN7DkC6tGkCqFOrXs26tevVAWLLnk2gtu3buHPr3o07gO/fwAkIH068uPHjyIsHWM68OYHn0KNLn069uvQA2LNrJ8C9u/fv4MOL//8eoLz58wTSq1/Pvr379+wDyJ9Pn4D9+/jz69/PP38AgAEEDhxIwOBBhAkVLmSYMMBDiBEJTKRY0eJFjBktBuDY0SMBkCFFjiRZ0uTIAClVriTQ0uVLmDFlzoQZwOZNnAR07uTZ0+dPoD0DDCValMBRpEmVLmXaVGkAqFGlEqBa1epVrFm1Xg3Q1etXAmHFjiVb1uxZsgHUrmVLwO1buHHlzqUbN8BdvHkJ7OXb1+9fwIH9BiBc2DABxIkVL2bc2PHiAJElTyZQ2fJlzJk1b8YcwPNn0AREjyZd2vRp1KUDrGbdmsBr2LFlz6ZdW3YA3Ll1E+Dd2/dv4MGF/w5Q3P/4cQLJlS9n3tz5c+YBpE+nTsD6dezZtW/nnj3Ad/DhCYwnX978efTpzQdg3949Afjx5c+nX9/+/AD59e8n0N8/QAICBxIsaPDgwQAKFzIk4PAhxIgSJ1KMGOAixowENnLs6PEjyJAeA5AsaZIAypQqV7Js6XJlgJgyZxKoafMmzpw6d+IM4PMnUAJChxItavQo0qIBljJtSuAp1KhSp1KtKjUA1qxaCXDt6vUr2LBivwYoa/YsgbRq17Jt6/Yt2wBy59IlYPcu3rx69/LNG+Av4MAEBhMubPgw4sSGAzBu7JgA5MiSJ1OubHlygMyaNxPo7Pkz6NCiR4MOYPo0agL/qlezbu36NezWAWbTrk3gNu7cunfz7q07APDgwgkQL278OPLkyo8HaO78OYHo0qdTr279OvUA2rdzJ+D9O/jw4seTDx/gPPr0BNazb+/+Pfz47gPQr2+fAP78+vfz7+8fIAGBAgMUNHiQQEKFCxk2dPiQYQCJEykSsHgRY0aNGzlmDPARZEgCI0mWNHkSZUqTAVi2dEkAZkyZM2nWtDkzQE6dOwn09PkTaFChQ38GMHoUKQGlS5k2dfoUatMAU6lWJXAVa1atW7l21RoAbFixBMiWNXsWbVq1ZwO0dfuWQFy5c+nWtXuXbgC9e/kS8PsXcGDBgwkHDnAYcWICixk3/3b8GHJkxwEoV7ZMAHNmzZs5d/a8OUBo0aMJlDZ9GnVq1atRB3D9GjYB2bNp17Z9G3ftALt59ybwG3hw4cOJFxceAHly5QSYN3f+HHp06c8DVLd+nUB27du5d/f+nXsA8ePJEzB/Hn169evZpw/wHn58AvPp17d/H39++wH49/cPkIDAgQQLGjyIsGCAhQwbEngIMaLEiRQrSgyAMaNGAhw7evwIMqTIjwFKmjxJIKXKlSxbunzJMoDMmTQJ2LyJM6fOnTxzBvgJNCiBoUSLGj2KNKnRAEybOiUANarUqVSrWp0aIKvWrQS6ev0KNqzYsWADmD2LloDatWzbun0Lt/9tgLl06xK4izev3r18++oNADiwYAKECxs+jDix4sMBGjt+TCCy5MmUK1u+TDmA5s2cCXj+DDq06NGkQwc4jTo1gdWsW7t+DTu26wC0a9smgDu37t28e/veHSC48OEEihs/jjy58uXIAzh/Dp2A9OnUq1u/jr16gO3cuxP4Dj68+PHky4sPgD69egLs27t/Dz++/PcB6tu/TyC//v38+/sHSEDgQIIDAxxEmJDAQoYNHT6EGNFhAIoVLRLAmFHjRo4dPW4MEFLkSAIlTZ5EmVLlSpQBXL6ESUDmTJo1bd7EWTPATp49CfwEGlToUKJFhQZAmlQpAaZNnT6FGlXq0wD/Va1eJZBV61auXb1+5RpA7FiyBMyeRZtW7Vq2aQO8hRuXwFy6de3exZvXbgC+ff0SABxY8GDChQ0PDpBY8WICjR0/hhxZ8mTIASxfxkxA82bOnT1/Bt05wGjSpQmcRp1a9WrWrVUHgB1bNgHatW3fxp1b9+0AvX3/JhBc+HDixY0fJx5A+XLmBJw/hx5dOgDq1a1fvx5A+3buALx/Bx8+PAEA5c2fR48+wHr27QG8hx9fvnwCAOzfx58/fwD+/f0DBCBwIMGCBQkASKhwIUOGAQIMEDBAwAABAQIAyKhxI0eOBACADCly5MgAAgYIGCBggIABAQDAjClz5kwCAG7i/8ypU2eAAQIGCBggYICAAQCOIk2qVCkBAE6fQo0aVcAAAQMEDBAwQMAAAF6/gg0blgCAsmbPokU7QMAAAQMEDBAwQACAunbv4sVLAADfvn7//hUwQMAAAQMEDBAwAADjxo4fPyYAYDLlypYtBxggYICAAQIGCBgAYDTp0qZNEwCgejXr1q0DCBggYICAAQIGBACgezfv3r0JAAgufDhx4gECDBAwQMAAAQECAIgufTp16gQAYM+ufTt37QG+fwcgfjz58uUJAEivfj379u7fw2dPAAD9+vbv48+vf/99AgAAAhA4kGBBgwcRJlS4kGHDhAQARJQ4kWJFixcxUiQAgJVjR48fQYYUOfIjAQAnUaZUuZJlS5cqCQCQOZNmTZs3ceasSQBAT58/gQYVOpQoUAIAkCZVupRpU6dPlxIAMJVqVatXsWbVapUAAK9fwYYVO5Zs2bAEAKRVu5ZtW7dv4bIlAIBuXbt38ebVu/cuAQB/AQcWPJhwYcOCCQBQvJhxY8ePIUduTABAZcuXMWfWvJkzZgIBAQAh/wtORVRTQ0FQRTIuMAMBAAAALBUBrAAzAI8AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIHEiwoEGCARImJMCwocOHECNKfBigosWLBDJq3Mixo8ePHAOIHEmSgMmTKFOqXMkyZYCXMGMSmEmzps2bOHPaDMCzp08CQIMKHUq0qNGhAZIqXUqgqdOnUKNKnQo1gNWrWAlo3cq1q9evYLsGGEu2LIGzaNOqXcu2rdoAcOPKJUC3rt27ePPqvRugr9+/BAILHky4sOHDhAMoXsyYgOPHkCNLnkw5coDLmDMT2My5s+fPoEN7DkC6tGkCqFOrXs26tevVAWLLnk2gtu3buHPr3o07gO/fwAkIH068uPHjyIsHWM68OYHn0KNLn069uvQA2LNrJ8C9u/fv4MOL//8eoLz58wTSq1/Pvr379+wDyJ9Pn4D9+/jz69/PP38AgAEEDhxIwOBBhAkVLmSYMMBDiBEJTKRY0eJFjBktBuDY0SMBkCFFjiRZ0uTIAClVriTQ0uVLmDFlzoQZwOZNnAR07uTZ0+dPoD0DDCValMBRpEmVLmXaVGkAqFGlEqBa1epVrFm1Xg3Q1etXAmHFjiVb1uxZsgHUrmVLwO1buHHlzqUbN8BdvHkJ7OXb1+9fwIH9BiBc2DABxIkVL2bc2PHiAJElTyZQ2fJlzJk1b8YcwPNn0AREjyZd2vRp1KUDrGbdmsBr2LFlz6ZdW3YA3Ll1E+Dd2/dv4MGF/w5Q3P/4cQLJlS9n3tz5c+YBpE+nTsD6dezZtW/nnj3Ad/DhCYwnX978efTpzQdg3949Afjx5c+nX9/+/AD59e8n0N8/QAICBxIsaPDgwQAKFzIk4PAhxIgSJ1KMGOAixowENnLs6PEjyJAeA5AsaZIAypQqV7Js6XJlgJgyZxKoafMmzpw6d+IM4PMnUAJChxItavQo0qIBljJtSuAp1KhSp1KtKjUA1qxaCXDt6vUr2LBivwYoa/YsgbRq17Jt6/Yt2wBy59IlYPcu3rx69/LNG+Av4MAEBhMubPgw4sSGAzBu7JgA5MiSJ1OubHlygMyaNxPo7Pkz6NCiR4MOYPo0agL/qlezbu36NezWAWbTrk3gNu7cunfz7q07APDgwgkQL278OPLkyo8HaO78OYHo0qdTr279OvUA2rdzJ+D9O/jw4seTDx/gPPr0BNazb+/+Pfz47gPQr2+fAP78+vfz7+8fIAGBAgMUNHiQQEKFCxk2dPiQYQCJEykSsHgRY0aNGzlmDPARZEgCI0mWNHkSZUqTAVi2dEkAZkyZM2nWtDkzQE6dOwn09PkTaFChQ4EGMHoUKQGlS5k2dfoUatMAU6lWJXAVa1atW7l21RoAbFixBMiWNXsWbVq1ZwO0dfuWQFy5c+nWtXuXbgC9e/kS8PsXcGDBgwkHDnAYcWICixk3/3b8GHJkxwEoV7ZMAHNmzZs5d/a8OUBo0aMJlDZ9GnVq1atRB3D9GjYB2bNp17Z9G3ftALt59ybwG3hw4cOJFxceAHly5QSYN3f+HHp06c8DVLd+nUB27du5d/f+nXsA8ePJEzB/Hn169evZpw/wHn58AvPp17d/H39++wH49/cPkIDAgQQLGjyIsGCAhQwbEngIMaLEiRQrSgyAMaNGAhw7evwIMqTIjwFKmjxJIKXKlSxbunzJMoDMmTQJ2LyJM6fOnTxzBvgJNCiBoUSLGj2KNKnRAEybOiUANarUqVSrWp0aIKvWrQS6ev0KNqzYsWADmD2LloDatWzbun0Lt/9tgLl06xK4izev3r18++oNADiwYAKECxs+jDix4sMBGjt+TCCy5MmUK1u+TDmA5s2cCXj+DDq06NGkQwc4jTo1gdWsW7t+DTu26wC0a9smgDu37t28e/veHSC48OEEihs/jjy58uXIAzh/Dp2A9OnUq1u/jr16gO3cuxP4Dj68+PHky4sPgD69egLs27t/Dz++/PcB6tu/TyC//v38+/sHSEDgQIIDAxxEmJDAQoYNHT6EGNFhAIoVLRLAmFHjRo4dPW4MEFLkSAIlTZ5EmVLlSpQBXL6ESUDmTJo1bd7EWTPATp49CfwEGlToUKJFhQZAmlQpAaZNnT6FGlXq0wD/Va1eJZBV61auXb1+5RpA7FiyBMyeRZtW7Vq2aQO8hRuXwFy6de3exZvXbgC+ff0SABxY8GDChQ0PDpBY8WICjR0/hhxZ8mTIASxfxkxA82bOnT1/Bt05wGjSpQmcRp1a9WrWrVUHgB1bNgHatW3fxp1b9+0AvX3/JhBc+HDixY0fJx5A+XLmBJw/hx5dOgEA1a1fx349wHbu3QF8Bx9e/HgCAMyfR58+fQD27d0DgB9f/vz5BADcx59fv/4A/f0DDCAwAICCBg8iREgAAMOGDh8+DBBggIABAgYEyAhgI8eOHj0SACByJMmSJQMIGCBggIABAgYEACBzJs2aNQkA/8ipcydPngMEDBAwQMAAAQMCAEiqdClTpgQAQI0qdepUAQMEDBAwQMAAAQEAgA0rduxYAgDOok2rVu0AAQMEDBAwQMAAAQDu4s2rVy8BAH7/Ag4cWMAAAQMEDBAwQEAAAI4fQ44cmQCAypYvY8Y8QMAAAQMEDBAwIACA0qZPo0ZNAADr1q5fvw4wQMAAAQMEDBAQAADv3r5//yYAYDjx4saNBwggYICAAQICQAcgfTr16tUJAMiufTt37gG+fwcgfjz58ubJEwCgfj379u7fw4/fngCA+vbv48+vfz///v4BAhA4kGBBgwcPEgCwkGFDhw8hRpTokAAAixcxZtS4kZljx4wEAIQUOZJkSZMnUZIkAIBlS5cvYcaUOfMlAQA3cebUuZNnT586CQAQOpRoUaNHkSYtSgBAU6dPoUaVOpUqVAIAsGbVupVrV69ftxIAMJZsWbNn0aZVa5YAALdv4caVO5du3bgEAOTVu5dvX79/AfMlAIBwYcOHESdWvPgwAQCPIUeWPJlyZcuSCQDQvJlzZ8+fQYfuHBAAIf8LTkVUU0NBUEUyLjADAQAAACwVAawAMwCPAIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAI/wAJCBxIsGDBAAgREljIsKHDhxAjSiQQoKLFiwQyatzIsaPHjxwDiBxJkoDJkyhTqlzJMmWAlzBjEphJs6bNmzhz2gzAs6dPAkCDCh1KtKjRoQGSKl1KoKnTp1CjSp0KNYDVq1gJaN3KtavXr2C7BhhLtiyBs2jTql3Ltq3aAHDjyiVAt67du3jz6r0boK/fvwQCCx5MuLDhw4QDKF7MmIDjx5AjS55MOXKAy5gzE9jMubPnz6BDew5AurRpAqhTq17NurXr1QFiy55NoLbt27hz696NO4Dv38AJCB9OvLjx48iLB1jOvDmB59CjS59Ovbr0ANizayfAvbv37+DDi///HqC8+fME0qtfz769+/fsA8ifT5+A/fv48+vfzz9/AIABBA4cSMDgQYQJFS5kmDDAQ4gRCUykWNHiRYwZLQbg2NEjAZAhRY4kWdLkyAApVa4k0NLlS5gxZc6EGcDmTZwEdO7k2dPnT6A9AwwlWpTAUaRJlS5l2lRpAKhRpRKgWtXqVaxZtV4N0NXrVwJhxY4lW9bsWbIB1K5lS8DtW7hx5c6lGzfAXbx5Cezl29fvX8CB/QYgXNgwAcSJFS9m3Njx4gCRJU8mUNnyZcyZNW/GHMDzZ9AERI8mXdr0adSlA6xm3ZrAa9ixZc+mXVt2ANy5dRPg3dv3b+DBhf8OUNz/+HECyZUvZ97c+XPmAaRPp07A+nXs2bVv5549wHfw4QmMJ1/e/Hn06c0HYN/ePQH48eXPp1/f/vwA+fXvJ9DfP0ACAgcSLGjw4MEAChcyJODwIcSIEidSjBjgIsaMBDZy7OjxI8iQHgOQLGmSAMqUKleybOlyZYCYMmcSqGnzJs6cOnfiDODzJ1ACQocSLWr0KNKiAZYybUrgKdSoUqdSrSo1ANasWglw7er1K9iwYr8GKGv2LIG0ateybev2LdsAcufSJWD3Lt68evfyzRvgL+DABAYTLmz4MOLEhgMwbuyYAOTIkidTrmx5coDMmjcT6Oz5M+jQokeDDmD6NGoC/6pXs27t+jXs1gFm065N4Dbu3Lp38+6tOwDw4MIJEC9u/Djy5MqPB2ju/DmB6NKnU69u/Tr1ANq3cyfg/Tv48OLHkw8f4Dz69ATWs2/v/j38+O4D0K9vnwD+/Pr38+/vHyABgQIDFDR4kEBChQsZNnT4kGEAiRMpErB4EWNGjRs5ZgzwEWRIAiNJljR5EmVKkwFYtnRJAGZMmTNp1rQ5M0BOnTsJ9PT5E2hQoUOBBjB6FCkBpUuZNnX6FGrTAFOpViVwFWtWrVu5dtUaAGxYsQTIljV7Fm1atWcDtHX7lkBcuXPp1rV7l24AvXv5EvD7F3BgwYMJBw5wGHFiAosZN/92/BhyZMcBKFe2TABzZs2bOXf2vDlAaNGjCZQ2fRp1atWrUQdw/Ro2Admzade2fRt37QC7efcm8Bt4cOHDiRcXHgB5cuUEmDd3/hx6dOnPA1S3fp1Adu3buXf3/p17APHjyRMwfx59evXr2acP8B5+fALz6de3fx9/fvsB+Pf3D5CAwIEECxo8iLBggIUMGxJ4CDGixIkUK0oMgDGjRgIcO3r8CDKkyI8BSpo8SSClypUsW7p8yTKAzJk0Cdi8iTOnzp08cwb4CTQogaFEixo9ijSp0QBMmzolADWq1KlUq1qdGiCr1q0Eunr9Cjas2LFgA5g9i5aA2rVs27p9C7f/bYC5dOsSuIs3r969fPvqDQA4sGAChAsbPow4seLDARo7fkwgsuTJlCtbvkw5gObNnAl4/gw6tOjRpEMHOI06NYHVrFu7fg07tusAtGvbJoA7t+7dvHv73h0guPDhBIobP448ufLlyAM4fw6dgPTp1Ktbv469eoDt3LsT+A4+vPjx5MuLD4A+vXoC7Nu7fw8/vvz3Aerbv08gv/79/Pv7B0hA4ECCAwMcRJiQwEKGDR0+hBjRYQCKFS0SwJhR40aOHT1uDBBS5EgCJU2eRJlS5UqUAVy+hElA5kyaNW3exFkzwE6ePQn8BBpU6FCiRYUGQJpUKQGmTZ0+hRpV6tMA/1WtXiWQVetWrl29fuUaQOxYsgTMnkWbVu1atmkDvIUbl8BcunXt3sWb124Avn39EgAcWPBgwoUNDw6QWPFiAo0dP4YcWfJkyAEsX8ZMQPNmzp09fwbdOcBo0qUJnEadWvVq1q1VB4AdWzYB2rVt38adW/ftAL19/yYQXPhw4sWNHyceQPly5gScP4ceXToA6tWtX78eQPt27gC8fwcfPjwBAOXNn0ePPsB69u0BvIcfX758AgDs38efP38A/v39AwQgcCDBggUJAEiocCFDhgECDBAwQMAAAQECAMiocSNHjgQAgAwpcuTIAAIGCBggYICAAQEAwIwpc+ZMAgBu4v/MqVPnAAEDBAwQMEDAgAAAjiJNqlQpAQBOn0KNGlXAAAEDBAwQMEDAAABev4ING5YAgLJmz6JFO0DAAAEDBAwQMEAAgLp27+LFSwAA375+//4VMEDAAAEDBAwQMAAA48aOHz8mAGAy5cqWLQ8QMEDAAAEDBAwIAGA06dKmTRMAoHo169atAwwQMEDAAAEDBAQAoHs37969CQAILnw4ceIBAggYIGCAgAEBAgCILn06deoEAGDPrn07d+0Bvn8HIH48+fLlCQBIr349+/bu38NnTwAA/fr27+PPr3//fQIAAAIQOJBgQYMHESZUuJBhw4QEAESUOJFiRYsXMVIkAICVY0ePH0GGFDnyIwEAJ1GmVLmSZUuXKgkAkDmTZk2bN3HmrEkAQE+fP4EGFTqUKFACAJAmVbqUaVOnT5cSADCValWrV7Fm1WqVAACvX8GGFTuWbNmwBACkVbuWbVu3b+GyJQCAbl27d/Hm1bv3LgEAfwEHFjyYcGHDggkAULyYcWPHjyFHbkwAQGXLlzFn1ryZM2YCAQEAIf8LTkVUU0NBUEUyLjADAQAAACwoAawACwB+AIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAI/wAJCBwYoGAAAgESKlxIIIDDhxAJBJhIsSKBABgzaiQQoKPHjwQCiBxJkgCBAChTqiQQoKXLlwQCyJxJk0CAmzhzEgjAs6dPAgGCCh1KIIDRo0gJBFjKtCmBAFCjSiUQoKrVqwQCaN3KlUCAr2DDEghAtqxZAgHSql1LIIDbt3AJBJhLty6BAHjz6iUQoK/fvwQCCB5MmECAw4gTEwjAuLFjAgEiS55MIIDly5gJBNjMuTOBAKBDiyYQoLTp0wQCqF7NmkCA17BjEwhAu7ZtAgFy695NIIDv38AJBBhOvDiBAMiTKycQoLnz5wQCSJ9OnUCA69izEwjAvbt3AgHCi/8fTyCA+fPoCQRYz749gQDw48snEKC+/fsEAujfz59AAIABBA4cSCDAQYQJCQRg2NAhgQARJU4kEMDiRYwEAmzk2JFAAJAhRRIIUNLkSQIBVK5kSSDAS5gxCQSgWdMmgQA5de4kEMDnT6AEAgwlWpRAAKRJlRII0NTpUwIBpE6lSiDAVaxZCQTg2tUrgQBhxY4lEMDsWbQEAqxl25ZAALhx5RIIUNfuXQIB9O7lSyDAX8CBCQQgXNgwgQCJFS8mEMDxY8gEAkymXJlAAMyZNRMI0NnzZwIBRI8mTSDAadSpCQRg3do1gQCxZc8mEMD2bdwEAuzm3ZtAAODBhRMIUNz/+HECAZQvZ04gwHPo0QkEoF7dOoEA2bVvJxDA+3fwBAKMJ1+eQAD06dUTCNDe/XsCAeTPp08gwH38+QkE4N/fP0ACAQYSLEggAMKECgkEaOjwIYEAEidSJBDgIsaMBAJw7OiRQICQIkcSCGDyJEoCAVaybEkgAMyYMgkEqGnzJoEAOnfyBBDgJ9CgAAIQLWoUQICkSpcCCBBggIABAgYICBAAQAABAwQMEDBAwIAAAAYIGCBggIABAgYIACBggIABAgYIGCBgAIABAgYIGCBggIABAgAIGCBggIABAgYIGABggIABAgYIGCBggAAAAQYIGCBggIABAgIACBBAwAABDwMEDAgQAECA2LEB0KYdEAAh/wtORVRTQ0FQRTIuMAMBAAAALBQBrAAzAI8AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIHEiwoMGDCBMqXFgwgMOHEAlInEixosWLGCsG2MixI4GPIEOKHEmypMgAKFOqJMCypcuXMGPKfBmgps2bBHLq3Mmzp8+fPAMIHUqUgNGjSJMqXco0aYCnUKMSmEq1qtWrWLNaDcC1q1cCYMOKHUu2rNmxAdKqXUugrdu3cOPKnQs3gN27eAno3cu3r9+/gPsGGEy4MIHDiBMrXsy4seIAkCNLJkC5suXLmDNrvhygs+fPBEKLHk26tOnTpAOoXs2agOvXsGPLnk07doDbuHMT2M27t+/fwIP7DkC8uHECyJMrX868ufPlAaJLn06guvXr2LNr3449gPfv4AmI/x9Pvrz58+jLB1jPvj2B9/Djy59Pv778APjz6yfAv79/gAQEDiRY0ODBgQEULmRIwOFDiBElTqQYMcBFjBkJbOTY0eNHkCE9BiBZ0iQBlClVrmTZ0uXKADFlziRQ0+ZNnDl17sQZwOdPoASEDiVa1OhRpEUDLGXalMBTqFGlTqVaVWoArFm1EuDa1etXsGHFfg1Q1uxZAmnVrmXb1u1btgHkzqVLwO5dvHn17uWbN8BfwIEJDCZc2PBhxIkNB2Dc2DEByJElT6Zc2fLkAJk1bybQ2fNn0KFFjwYdwPRp1ARUr2bd2vVr2K0DzKZdm8Bt3Ll17+bdW3cA4MGFEyBe3P/4ceTJlR8P0Nz5cwLRpU+nXt36deoBtG/nTsD7d/DhxY8nHz7AefTpCaxn3979e/jx3QegX98+Afz59e/n398/QAICBQYoaPAggYQKFzJs6PAhwwASJ1IkYPEixowaN3LMGOAjyJAERpIsafIkypQmA7Bs6ZIAzJgyZ9KsaXNmgJw6dxLo6fMn0KBChwINYPQoUgJKlzJt6vQp1KYBplKtSuAq1qxat3LtqjUA2LBiCZAta/Ys2rRqzwZo6/Ytgbhy59Kta/cu3QB69/Il4Pcv4MCCBxMOHOAw4sQEFjNu7Pgx5MiOA1CubJkA5syaN3Pu7HlzgNCiRxMobfo06tT/qlejDuD6NWwCsmfTrm37Nu7aAXbz7k3gN/DgwocTLy48APLkygkwb+78OfTo0p8HqG79OoHs2rdz7+79O/cA4seTJ2D+PPr06tezTx/gPfz4BObTr2//Pv789gPw7+8fIAGBAwkWNHgQYcEACxk2JPAQYkSJEylWlBgAY0aNBDh29PgRZEiRHwOUNHmSQEqVK1m2dPmSZQCZM2kSsHkTZ06dO3nmDPATaFACQ4kWNXoUaVKjAZg2dUoAalSpU6lWtTo1QFatWwl09foVbFixY8EGMHsWLQG1a9m2dfsWbtsAc+nWJXAXb169e/n21RsAcGDBBAgXNnwYcWLFhwM0/3b8mEBkyZMpV7Z8mXIAzZs5E/D8GXRo0aNJhw5wGnVqAqtZt3b9GnZs1wFo17ZNAHdu3bt59/a9O0Bw4cMJFDd+HHly5cuRB3D+HDoB6dOpV7d+HXv1ANu5dyfwHXx48ePJlxcfAH169QTYt3f/Hn58+e8D1Ld/n0B+/fv59/cPkIDAgQQHBjiIMCGBhQwbOnwIMaLDABQrWiSAMaPGjRw7etwYIKTIkQRKmjyJMqXKlSgDuHwJk4DMmTRr2ryJs2aAnTx7EvgJNKjQoUSLCg2ANKlSAkybOn0KNarUpwGqWr1KIKvWrVy7ev3KNYDYsWQJmD2LNq3atWzTBngLN/8ugbl069q9izev3QB8+/olADiw4MGECxseHCCx4sUEGjt+DDmy5MmQA1i+jJmA5s2cO3v+DLpzgNGkSxM4jTq16tWsW6sOADu2bAK0a9u+jTu37tsBevv+TSC48OHEixs/TjyA8uXMCTh/Dj269OnUowe4jj07ge3cu3v/Dj689wDky5sngD69+vXs27tfHyC+/PkE6tu/jz+//v34A/gHGEDgwAAEDB5EmFDhQoYJAzyEGJHARIoVLV7EmNFiAI4dPRIAGVLkSJIlTY4MkFLlSgItXb6EGVPmTJgBbN7ESUDnTp49ff4E2jPAUKJFCRxFmlTpUqZNlQaAGlUqAar/Va1exZpV69UAXb1+JRBW7FiyZc2eJRtA7Vq2BNy+hRtX7ly6cQPcxZuXwF6+ff3+BRzYbwDChQ0TQJxY8WLGjR0vDhBZ8mQClS1fxpxZ82bMATx/Bk1A9GjSpU2fRl06wGrWrQm8hh1b9mzatWUHwJ1bNwHevX3/Bh5c+O8AxY0fJ5Bc+XLmzQE8hx5duvQA1a1fB5Bd+3bu3AkAAB9e/PjxAcyfRw9A/Xr27dsTABBf/nz69APcx58fwH7+/f0DBCBQIAEABg8iTJgwQIABAgYIGCAgQAAAFi9izJiRAICOHj+CBBlAwAABAwQMEDAgAICWLl/ChEkAAM2aNm/e/wwwQMAAAQMEDBAwAADRokaPHiUAYCnTpk6dChggYICAAQIGCBgAYCvXrl69EgAgdizZsmUHCBggYICAAQIGCAAgdy7dunUJAMirdy9fvgIGCBggYICAAQIGAEiseDFjxgQAQI4sefLkAAMEDBAwQMAAAQMAgA4tevRoAgBOo06tWnUAAQMEDBAwQMCAAABu486tWzcBAL5/Aw8ePECAAQIGCBggIEAAAM6fQ48enQCA6tavY8ceYDv37gC+gw8vXjwBAObPo0+vfj379ukJAIgvfz79+vbv46dPAAD//v4BAhA4kGBBgwcRJlS4kGFDAgAgRpQ4kWJFixcnEgCwkZNjR48fQYYU6ZEAAJMnUaZUuZJly5QEAMSUOZNmTZs3cdIkAIBnT58/gQYVOvQnAQBHkSZVupRpU6dKCQCQOpVqVatXsWatSgBAV69fwYYVO5YsWAIA0KZVu5ZtW7dv1xIAMJduXbt38ebVa5cAAL9/AQcWPJhw4cAEACRWvJhxY8ePITMmAIByZcuXMWfWvPkygYAAIf8LTkVUU0NBUEUyLjADAQAAACwoAawACgB+AIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAIpwADCBRIoGDBAAgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPHjyBDihxJsqTJkyhTqlzJsqXLlzBjypxJs6bHAQIGCBggIIBPAQMEDBAwQMCAAAMEDBAwQMAAAQMCCBggYICAAQIGCBgwQMAAAQMEDBAwQICAAQIGCBggYICAAQMEDBAwQMAAAQMCBBggYICAAQIGCAhAWMAAAQMEDAgQAIBjxwEiRw4IACH/C05FVFNDQVBFMi4wAwEAAAAsKAGsAAoAfgCCAAAAzJlmZmbMmZnM////AAAAAAAAAAAACKIACQgUGKCgwYMIEypcyLChw4cQI0qcSLGixYsYM2rcyLGjx48gQ4ocSbKkyZMoU6pcybKly5cwY8oEOUDAAAEDBATYKWCAgAECBggYEGCAgAECBggYIGBAAAEDBAwQMEDAAAEDBggYIGCAgAECBggQMEDAAAEDBAwQMGCAgAECBggYIGBAgAADBAwQMEDAAAEBAgsYIGCAgAEBEisOAKBx44AAIf8LTkVUU0NBUEUyLjADAQAAACwTAawAMwCPAIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAI/wAJCBxIsKDBAAgDEFjIsKHDhxAjSlwYoKLFiwQyatzIsaPHjxwDiBxJkoDJkyhTqlzJMmWAlzBjEphJs6bNmzhz2gzAs6dPAkCDCh1KtKjRoQGSKl1KoKnTp1CjSp0KNYDVq1gJaN3KtavXr2C7BhhLtiyBs2jTql3Ltq3aAHDjyiVAt67du3jz6r0boK/fvwQCCx5MuLDhw4QDKF7MmIDjx5AjS55MOXKAy5gzE9jMubPnz6BDew5AurRpAqhTq17NurXr1QFiy55NoLbt27hz696NO4Dv38AJCB9OvLjx48iLB1jOvDmB59CjS59Ovbr0ANizayfAvbv37+DDi///HqC8+fME0qtfz769+/fsA8ifT5+A/fv48+vfzz9/AIABBA4cSMDgQYQJFS5kmDDAQ4gRCUykWNHiRYwZLQbg2NEjAZAhRY4kWdLkyAApVa4k0NLlS5gxZc6EGcDmTZwEdO7k2dPnT6A9AwwlWpTAUaRJlS5l2lRpAKhRpRKgWtXqVaxZtV4N0NXrVwJhxY4lW9bsWbIB1K5lS8DtW7hx5c6lGzfAXbx5Cezl29fvX8CB/QYgXNgwAcSJFS9m3Njx4gCRJU8mUNnyZcyZNW/GHMDzZ9AERI8mXdr0adSlA6xm3ZrAa9ixZc+mXVt2ANy5dRPg3dv3b+DBhf8OUNz/+HECyZUvZ97c+XPmAaRPp07A+nXs2bVv5549wHfw4QmMJ1/e/Hn06c0HYN/ePQH48eXPp1/f/vwA+fXvJ9DfP0ACAgcSLGjw4MEAChcyJODwIcSIEidSjBjgIsaMBDZy7OjxI8iQHgOQLGmSAMqUKleybOlyZYCYMmcSqGnzJs6cOnfiDODzJ1ACQocSLWr0KNKiAZYybUrgKdSoUqdSrSo1ANasWglw7er1K9iwYr8GKGv2LIG0ateybev2LdsAcufSJWD3Lt68evfyzRvgL+DABAYTLmz4MOLEhgMwbuyYAOTIkidTrmx5coDMmjcT6Oz5M+jQokeDDmD6NGoC/6pXs27t+jVs1gFm065N4Dbu3Lp38+6tOwDw4MIJEC9u/Djy5MqPB2ju/DmB6NKnU69u/Tr1ANq3cyfg/Tv48OLHkw8f4Dz69ATWs2/v/j38+O4D0K9vnwD+/Pr38+/vHyABgQIDFDR4kEBChQsZNnT4kGEAiRMpErB4EWNGjRs5ZgzwEWRIAiNJljR5EmVKkwFYtnRJAGZMmTNp1rQ5M0BOnTsJ9PT5E2hQoUOBBjB6FCkBpUuZNnX6FGrTAFOpViVwFWtWrVu5dtUaAGxYsQTIljV7Fm1atWcDtHX7lkBcuXPp1rV7l24AvXv5EvD7F3BgwYMJBw5wGHFiAosZN/92/BhyZMcBKFe2TABzZs2bOXf2vDlAaNGjCZQ2fRp1atWrUQdw/Ro2Admzade2fRt37QC7efcm8Bt4cOHDiRcXHgB5cuUEmDd3/hx6dOnPA1S3fp1Adu3buXf3/p17APHjyRMwfx59evXr2acP8B5+fALz6de3fx9/fvsB+Pf3D5CAwIEECxo8iLBggIUMGxJ4CDGixIkUK0oMgDGjRgIcO3r8CDKkyI8BSpo8SSClypUsW7p8yTKAzJk0Cdi8iTOnzp08cwb4CTQogaFEixo9ijSp0QBMmzolADWq1KlUq1qdGiCr1q0Eunr9Cjas2LFgA5g9i5aA2rVs27p9C7f/bYC5dOsSuIs3r969fPvqDQA4sGAChAsbPow4seLDARo7fkwgsuTJlCtbvkw5gObNnAl4/gw6tOjRpEMHOI06NYHVrFu7fg07tusAtGvbJoA7t+7dvHv73h0guPDhBIobP448ufLlyAM4fw6dgPTp1Ktbv469eoDt3LsT+A4+vPjx5MuLD4A+vXoC7Nu7fw8/vvz3Aerbv08gv/79/Pv7B0hA4ECCAwMcRJiQwEKGDR0+hBjRYQCKFS0SwJhR40aOHT1uDBBS5EgCJU2eRJlS5UqUAVy+hElA5kyaNW3exFkzwE6ePQn8BBpU6FCiRYUGQJpUKQGmTZ0+hRpV6tMA/1WtXiWQVetWrl29fuUaQOxYsgTMnkWbVu1atmkDvIUbl8BcunXt3sWb124Avn39EgAcWPBgwoUNDw6QWPFiAo0dP4YcWfJkyAEsX8ZMQPNmzp09fwbdOcBo0qUJnEadWvVq1q1VB4AdWzYB2rVt38adW/ftAL19/yYQXPhw4sWNHyceQPly5gScP4ceXToA6tWtX78eQPt27gC8fwcfPjwBAOXNn0ePPsB69u0BvIcfX758AgDs38efP38A/v39AwQgcCDBggUJAEiocCFDhgECDBAwQMAAAQECAMiocSNHjgQAgAwpcuTIAAIGCBggYICAAQEAwIwpc+ZMAgBu4v/MqVNngAECBggYIGCAgAEAjiJNqlQpAQBOn0KNGlXAAAEDBAwQMEDAAABev4ING5YAgLJmz6JFO0DAAAEDBAwQMEAAgLp27+LFSwAA375+//4VMEDAAAEDBAwQMAAA48aOHz8mAGAy5cqWLQcYIGCAgAECBggYAGA06dKmTRMAoHo169atAwgYIGCAgAECBgQAoHs37969CQAILnw4ceIBAgwQMEDAAAEBAgCILn06deoEAGDPrn07d+0Bvn8HIH48+fLlCQBIr349+/bu38NnTwAA/fr27+PPr3//fQIAAAIQOJBgQYMHESZUuJBhw4QEAESUOJFiRYsXMVIkAICVY0ePH0GGFDnyIwEAJ1GmVLmSZUuXKgkAkDmTZk2bN3HmrEkAQE+fP4EGFTqUKFACAJAmVbqUaVOnT5cSADCValWrV7Fm1WqVAACvX8GGFTuWbNmwBACkVbuWbVu3b+GyJQCAbl27d/Hm1bv3LgEAfwEHFjyYcGHDggkAULyYcWPHjyFHbkwAQGXLlzFn1ryZM2YCAQEAIf8LTkVUU0NBUEUyLjADAQAAACwnAawACwB+AIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAI/wAJCBQYoGBBAgESKlxIIIDDhxAJBJhIsSKBABgzaiQQoKPHjwQCiBxJkkCAkyhTEgjAsqVLAgFiypxJIIDNmzgJBNjJsyeBAECDCiUQoKjRowQCKF3KlECAp1CjEghAtapVAgGyat1KIIDXr2AJBBhLtiyBAGjTqiUQoK3btwQCyJ1Ll0CAu3jzEgjAt69fAgECCx5MIIDhw4gJBFjMuDGBAJAjSyYQoLLlywQCaN7MmUCAz6BDEwhAurRpAgFSq15NIIDr17AJBJhNuzaBALhz6yYQoLfv3wQCCB9OnECA48iTEwjAvLlzAgGiS59OIID169gJBNjOvTuBAODDi/8nEKC8+fMEAqhfz55AgPfw4xMIQL++fQIB8uvfTyCAf4ABBA4MQCDAQYQJCQRg2NAhgQARJU4kEMDiRYwEAmzk2JFAAJAhRRIIUNLkSQIBVK5kSSDAS5gxCQSgWdMmgQA5de4kEMDnT6AEAgwlWpRAAKRJlRII0NTpUwIBpE6lSiDAVaxZCQTg2tUrgQBhxY4lEMDsWbQEAqxl25ZAALhx5RIIUNfuXQIB9O7lSyDAX8CBCQQgXNgwgQCJFS8mEMDxY8gEAkymXJlAAMyZNRMI0NnzZwIBRI8mTSDAadSpCQRg3do1gQCxZc8mEMD2bdwEAuzm3ZtAAODBhRMIUNz/+HECAZQvZ04gwHPo0QkEoF7dOoEA2bVvJxDA+3fwBAKMJ1+eQAD06dUTCNDe/XsCAeTPp08gwH38+QkE4N/fP0ACAQYSLEggAMKECgkEaOjwIYEAEidSJBDgIsaMBAJw7OiRQICQIkcSCGDyJEoCAVaybEkgAMyYMgkEqGnzJoEAOnfyJBDgJ9CgAAIQLWoUQICkSpcCCBBggIABAgYICBAAQAABAwQMEDBAwIAAAAIMEDBAwAABAwQMABBAwAABAwQMEDBAAIABAgYIGCBggIABAgAEGCBggIABAgYIGAAggIABAgYIGCBggAAAAQYIGCBggIABAgIACBBggIABDwIGCAgQAECA2LEB0K4dEAAh/wtORVRTQ0FQRTIuMAMBAAAALCcBrAAKAH4AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAinAAMIFEigYMEACBMqXMiwocOHECNKnEixosWLGDNq3Mixo8ePIEOKHEmypMmTKFOqXMmypcuXMGPKnEmzpscBAgYIGCAggE8BAwQMEDBAwIAAAwQMEDBAwAABAwIIGCBggIABAgYIGDBAwAABAwQMEDBAgIABAgYIGCBggIABAwQMEDBAwAABAwIEGCBggIABAgYICEBYwAABAwQMCBAAgGPHASJHDggAIf8LTkVUU0NBUEUyLjADAQAAACwnAawACgB+AIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAIogAJCBQYoKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPHjyBDihxJsqTJkyhTqlzJsqXLlzBjygQ5QMAAAQMEBNgpYICAAQIGCBgQYICAAQIGCBggYIAAAQMEDBAwQMAAAQMGCBggYICAAQIGCBAwQMAAAQMEDBAwYICAAQIGCBggYICAAAMEDBAwQMAAAQECCxggYICAAQESKw4AoHHjgAAh/wtORVRTQ0FQRTIuMAMBAAAALBIBrAAzAI8AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIHEiwoMEACAMQWMiwocOHECNKXBigosWLBDJq3Mixo8ePHAOIHEmSgMmTKFOqXMkyZYCXMGMSmEmzps2bOHPaDMCzp08CQIMKHUq0qNGhAZIqXUqgqdOnUKNKnQo1gNWrWAlo3cq1q9evYLsGGEu2LIGzaNOqXcu2rdoAcOPKJUC3rt27ePPqvRugr9+/BAILHky4sOHDhAMoXsyYgOPHkCNLnkw5coDLmDMT2My5s+fPoEN7DkC6tGkCqFOrXs26tevVAWLLnk2gtu3buHPr3o07gO/fwAkIH068uPHjyIsHWM68OYHn0KNLn069uvQA2LNrJ8C9u/fv4MOL//8eoLz58wTSq1/Pvr379+wDyJ9Pn4D9+/jz69/PP38AgAEEDhxIwOBBhAkVLmSYMMBDiBEJTKRY0eJFjBktBuDY0SMBkCFFjiRZ0uTIAClVriTQ0uVLmDFlzoQZwOZNnAR07uTZ0+dPoD0DDCValMBRpEmVLmXaVGkAqFGlEqBa1epVrFm1Xg3Q1etXAmHFjiVb1uxZsgHUrmVLwO1buHHlzqUbN8BdvHkJ7OXb1+9fwIH9BiBc2DABxIkVL2bc2PHiAJElTyZQ2fJlzJk1b8YcwPNn0AREjyZd2vRp1KUDrGbdmsBr2LFlz6ZdW3YA3Ll1E+Dd2/dv4MGF/w5Q3P/4cQLJlS9n3tz5c+YBpE+nTsD6dezZtW/nnj3Ad/DhCYwnX978efTpzQdg3949Afjx5c+nX9/+/AD59e8n0N8/QAICBxIsaPDgwQAKFzIk4PAhxIgSJ1KMGOAixowENnLs6PEjyJAeA5AsaZIAypQqV7Js6XJlgJgyZxKoafMmzpw6d+IM4PMnUAJChxItavQo0qIBljJtSuAp1KhSp1KtKjUA1qxaCXDt6vUr2LBivwYoa/YsgbRq17Jt6/Yt2wBy59IlYPcu3rx69/LNG+Av4MAEBhMubPgw4sSGAzBu7JgA5MiSJ1OubHlygMyaNxPo7Pkz6NCiR4MOYPo0agL/qlezbu36NezWAWbTrk3gNu7cunfz7q07APDgwgkQL278OPLkyo8HaO78OYHo0qdTr279OvUA2rdzJ+D9O/jw4seTDx/gPPr0BNazb+/+Pfz47gPQr2+fAP78+vfz7+8fIAGBAgMUNHiQQEKFCxk2dPiQYQCJEykSsHgRY0aNGzlmDPARZEgCI0mWNHkSZUqTAVi2dEkAZkyZM2nWtDkzQE6dOwn09PkTaFChQ4EGMHoUKQGlS5k2dfoUatMAU6lWJXAVa1atW7l21RoAbFixBMiWNXsWbVq1ZwO0dfuWQFy5c+nWtXuXbgC9e/kS8PsXcGDBgwkDDnAYcWICixk3/3b8GHJkxwEoV7ZMAHNmzZs5d/a8OUBo0aMJlDZ9GnVq1atRB3D9GjYB2bNp17Z9G3ftALt59ybwG3hw4cOJFxceAHly5QSYN3f+HHp06c8DVLd+nUB27du5d/f+nXsA8ePJEzB/Hn169evZpw/wHn58AvPp17d/H39++wH49/cPkIDAgQQLGjyIsGCAhQwbEngIMaLEiRQrSgyAMaNGAhw7evwIMqTIjwFKmjxJIKXKlSxbunzJMoDMmTQJ2LyJM6fOnTxzBvgJNCiBoUSLGj2KNKnRAEybOiUANarUqVSrWp0aIKvWrQS6ev0KNqzYsWADmD2LloDatWzbun0Lt/9tgLl06xK4izev3r18++oNADiwYAKECxs+jDix4sMBGjt+TCCy5MmUK1u+TDmA5s2cCXj+DDq06NGkQwc4jTo1gdWsW7t+DTu26wC0a9smgDu37t28e/veHSC48OEEihs/jjy58uXIAzh/Dp2A9OnUq1u/jr16gO3cuxP4Dj68+PHky4sPgD69egLs27t/Dz++/PcB6tu/TyC//v38+/sHSEDgQIIDAxxEmJDAQoYNHT6EGNFhAIoVLRLAmFHjRo4dPW4MEFLkSAIlTZ5EmVLlSpQBXL6ESUDmTJo1bd7EWTPATp49CfwEGlToUKJFhQZAmlQpAaZNnT6FGlXq0wD/Va1eJZBV61auXb1+5RpA7FiyBMyeRZtW7Vq2aQO8hRuXwFy6de3exZvXbgC+ff0SABxY8GDChQ0PDpBY8WICjR0/hhxZ8mTIASxfxkxA82bOnT1/Bt05wGjSpQmcRp1a9WrWrVUHgB1bNgHatW3fxp1b9+0AvX3/JhBc+HDixY0fJx5A+XLmBJw/hx5dOgDq1a1fvx5A+3buALx/Bx8+PAEA5c2fR48+wHr27QG8hx9fvnwCAOzfx58/fwD+/f0DBCBwIMGCBQkASKhwIUOGAQIMEDBAwAABAQIAyKhxI0eOBACADCly5MgAAgYIGCBggIABAQDAjClz5kwCAG7i/8ypU2eAAQIGCBggYICAAQCOIk2qVCkBAE6fQo0aVcAAAQMEDBAwQMAAAF6/gg0blgCAsmbPokU7QMAAAQMEDBAwQACAunbv4sVLAADfvn7//hUwQMAAAQMEDBAwAADjxo4fPyYAYDLlypYtBxggYICAAQIGCBgAYDTp0qZNEwCgejXr1q0DCBggYICAAQIGBACgezfv3r0JAAgufDhx4gECDBAwQMAAAQECAIgufTp16gQAYM+ufTt37QG+fwcgfjz58uUJAEivfj379u7fw2dPAAD9+vbv48+vf/99AgAAAhA4kGBBgwcRJlS4kGHDhAQARJQ4kWJFixcxUiQAgJVjR48fQYYUOfIjAQAnUaZUuZJlS5cqCQCQOZNmTZs3ceasSQBAT58/gQYVOpQoUAIAkCZVupRpU6dPlxIAMJVqVatXsWbVapUAAK9fwYYVO5Zs2bAEAKRVu5ZtW7dv4bIlAIBuXbt38ebVu/cuAQB/AQcWPJhwYcOCCQBQvJhxY8ePIUduTABAZcuXMWfWvJkzZgIBAQAh/wtORVRTQ0FQRTIuMAMBAAAALCYBrAALAH4AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIFBigYEECARIqXEgggMOHEAkEmEixIoEAGDNqJBCgo8ePBAKIHEmSQICTKFMSCMCypUsCAWLKnEkggM2bOAkE2MmzJ4EAQIMKJRCgqNGjBAIoXcqUQICnUKMSCEC1qlUCAbJq3UoggNevYAkEGEu2LIEAaNOqJRCgrdu3BALInUuXQIC7ePMSCMC3r18CAQILHkwggOHDiAkEWMy4MYEAkCNLJhCgsuXLBAJo3syZQIDPoEMTCEC6tGkCAVKrXk0ggOvXsAkEmE27NoEAuHPrJhCgt+/fBAIIH06cQIDjyJMTCMC8uXMCAaJLn04ggPXr2AkE2M69O4EA4MOL/ycQoLz58wQCqF/PnkCA9/DjEwhAv759AgHy699PIIB/gAEEDgxAIMBBhAkJBGDY0CGBABElTiQQwOJFjAQCbOTYkUAAkCFFEghQ0uRJAgFUrmRJIMBLmDEJBKBZ0yaBADl17iQQwOdPoAQCDCValEAApEmVEgjQ1OlTAgGkTqVKIMBVrFkJBODa1SuBAGHFjiUQwOxZtAQCrGXblkAAuHHlEghQ1+5dAgH07uVLIMBfwIEJBCBc2DCBAIkVLyYQwPFjyAQCTKZcmUAAzJk1EwjQ2fNnAgFEjyZNIMBp1KkJBGDd2jWBALFlzyYQwPZt3AQC7Obdm0AA4MGFEwhQ3P/4cQIBlC9nTiDAc+jRCQSgXt06gQDZtW8nEMD7d/AEAownX55AAPTp1RMI0N79ewIB5M+nTyDAffz5CQTg398/QAIBBhIsSCAAwoQKCQRo6PAhgQASJ1IkEOAixowEAnDs6JFAgJAiRxIIYPIkSgIBVrJsSSAAzJgyCQSoafMmgQA6d/IkEOAn0KAAAhAtahRAgKRKlwII4HSAgAECBgQIACDAAAEDBAwQMEBAAAABBAwQMEDAAAEDBAAIMEDAAAEDBAwQMACAgAECBggYIGCAgAEAAgwQMEDAAAEDBAwAEEDAAAEDBAwQMEAAgAABBggYIGCAgAEBAAQoLWCAgAENAgIEABDg9WsAsmcHBAAh/wtORVRTQ0FQRTIuMAMBAAAALCYBrAAKAH4AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAinAAMIFEigYMEACBMqXMiwocOHECNKnEixosWLGDNq3Mixo8ePIEOKHEmypMmTKFOqXMmypcuXMGPKnEmzpscBAgYIGCAggE8BAwQMEDBAwIAAAwQMEDBAwAABAwIIGCBggIABAgYIGDBAwAABAwQMEDBAgIABAgYIGCBggIABAwQMEDBAwAABAwIEGCBggIABAgYICEBYwAABAwQMCBAAgGPHASJHDggAIf8LTkVUU0NBUEUyLjADAQAAACwmAawACgB+AIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAIoQAJCBxIMIDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPHjyBDihxJsqTJkyhTqlzJsqXLlzBjypzJcYCAAQIGCAjAU8AAAQMEDBAwIMAAAQMEDBAwQMAAAQIGCBggYICAAQIGDBAwQMAAAQMEDBAgYICAAQIGCBggYMAAAQMEDBAwQMAAAQEGCBggYICAAQICCBYwQMAAAQMCKF7MWHFAACH/C05FVFNDQVBFMi4wAwEAAAAsJgGsAAoAfgCCAAAAzJlmZmbMmZnM////AAAAAAAAAAAACKIACQgUGKCgwYMIEypcyLChw4cQI0qcSLGixYsYM2rcyLGjx48gQ4ocSbKkyZMoU6pcybKly5cwY8oEOUDAAAEDBATYKWCAgAECBggYECDAAAEDBAwQMEDAAAEDBAwQMEDAAAEDBggYIGCAgAECBggQMEDAAAEDBAwQMCDAAAEDBAwQMEDAgAACBggYIGCAgAEBAg8QMEDAAAEBEisOAKBx44AAIf8LTkVUU0NBUEUyLjADAQAAACwmAawACgB+AIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAIpgADCBRIoGDBAAgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPHjyBDihxJsqTJkyhTqlzJsqXLlzBjypxJs6bHAQIGCBggIIBPAQMEDBAwQMCAAAMEDBAwQMAAAQMCCBggYICAAQIGCAgwQMAAAQMEDBAwQICAAQIGCBggYICAAAMEDBAwQMAAAQMCBBggYICAAQIGCAhAWMAAAQMEBFgMoHHjAJAhBwQAIf8LTkVUU0NBUEUyLjADAQAAACwlAawACwB+AIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAI/wAJCBwYoGAAAgESKlxIIIDDhxAJBJhIsSKBABgzaiQQoKPHjwQCiBxJkkCAkyhTEgjAsqVLAgFiypxJIIDNmzgJBNjJsyeBAECDCiUQoKjRowQCKF3KlECAp1CjEghAtapVAgGyat1KIIDXr2AJBBhLtiyBAGjTqiUQoK3btwQCyJ1Ll0CAu3jzEgjAt69fAgECCx5MIIDhw4gJBFjMuDGBAJAjSyYQoLLlywQCaN7MmUCAz6BDEwhAurRpAgFSq15NgECA17BjEwhAu7ZtAgFy695NIIDv38AJBBhOvDiBAMiTKycQoLnz5wQCSJ9OnUCA69izEwjAvbt3AgHCi/8fTyCA+fPoCQRYz749gQDw48snEKC+/fsEAujfz59AAIABBA4cSCDAQYQJCQRg2NAhgQARJU4kEMDiRYwEAmzk2JFAAJAhRRIIUNLkSQIBVK5kSSDAS5gxCQSgWdMmgQA5de4kEMDnT6AEAgwlWpRAAKRJlRII0NTpUwIBpE6lSiDAVaxZCQTg2tUrgQBhxY4lEMDsWbQEAqxl25ZAALhx5RIIUNfuXQIB9O7lSyDAX8CBCQQgXNgwgQCJFS8mEMDxY8gEAkymXJlAAMyZNRMI0NnzZwIBRI8mTSDAadSpCQRg3do1gQCxZc8mEMD2bdwEAuzm3ZtAAODBhRMIUNz/+HECAZQvZ04gwHPo0QkEoF7dOoEA2bVvJxDA+3fwBAKMJ1+eQAD06dUTCNDe/XsCAeTPp08gwH38+QkE4N/fP0ACAQYSLEggAMKECgkEaOjwIYEAEidSJBDgIsaMBAJw7OiRQICQIkcSCGDyJEoCAVaybEkgAMyYMgkEqGnzJoEAOnfyBBDgJ9CgAAIQLWoUQICkSpcCCBBggIABAgYICBAAQAABAwQMEDBAwIAAAAYIGCBggIABAgYEACBggIABAgYIGCBgAIABAgYIGCBggIABAgAIGCBggIABAgYIGABggIABAgYIGCBgQAAAAQYIGCBggIABAgIACBBAwAABDwMEDAgQAECA2LEB0KYdEAAh/wtORVRTQ0FQRTIuMAMBAAAALBEBrAAzAI8AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIHEiwYMEACBESWMiwocOHECNKJBCgosWLBDJq3Mixo8ePHAOIHEmSgMmTKFOqXMkyZYCXMGMSmEmzps2bOHPaDMCzp08CQIMKHUq0qNGhAZIqXUqgqdOnUKNKnQo1gNWrWAlo3cq1q9evYLsGGEu2LIGzaNOqXcu2rdoAcOPKJUC3rt27ePPqvRugr9+/BAILHky4sOHDhAMoXsyYgOPHkCNLnkw5coDLmDMT2My5s+fPoEN7DkC6tGkCqFOrXs26tevVAWLLnk2gtu3buHPr3o07gO/fwAkIH068uPHjyIsHWM68OYHn0KNLn069uvQA2LNrJ8C9u/fv4MOL//8eoLz58wTSq1/Pvr379+wDyJ9Pn4D9+/jz69/PP38AgAEEDhxIwOBBhAkVLmSYMMBDiBEJTKRY0eJFjBktBuDY0SMBkCFFjiRZ0uTIAClVriTQ0uVLmDFlzoQZwOZNnAR07uTZ0+dPoD0DDCValMBRpEmVLmXaVGkAqFGlEqBa1epVrFm1Xg3Q1etXAmHFjiVb1uxZsgHUrmVLwO1buHHlzqUbN8BdvHkJ7OXb1+9fwIH9BiBc2DABxIkVL2bc2PHiAJElTyZQ2fJlzJk1b8YcwPNn0AREjyZd2vRp1KUDrGbdmsBr2LFlz6ZdW3YA3Ll1E+Dd2/dv4MGF/w5Q3P/4cQLJlS9n3tz5c+YBpE+nTsD6dezZtW/nnj3Ad/DhCYwnX978efTpzQdg3949Afjx5c+nX9/+/AD59e8n0N8/QAICBxIsaPDgwQAKFzIk4PAhxIgSJ1KMGOAixowENnLs6PEjyJAeA5AsaZIAypQqV7Js6XJlgJgyZxKoafMmzpw6d+IM4PMnUAJChxItavQo0qIBljJtSuAp1KhSp1KtKjUA1qxaCXDt6vUr2LBivwYoa/YsgbRq17Jt6/Yt2wBy59IlYPcu3rx69/LNG+Av4MAEBhMubPgw4sSGAzBu7JgA5MiSJ1OubHlygMyaNxPo7Pkz6NCiR4MOYPo0agL/qlezbu36NezWAWbTrk3gNu7cunfz7q07APDgwgkQL278OPLkyo8HaO78OYHo0qdTr279OvUA2rdzJ+D9O/jw4seTDx/gPPr0BNazb+/+Pfz47gPQr2+fAP78+vfz7+8fIAGBAgMUNHiQQEKFCxk2dPiQYQCJEykSsHgRY0aNGzlmDPARZEgCI0mWNHkSZUqTAVi2dEkAZkyZM2nWtDkzQE6dOwn09PkTaFChQ4EGMHoUKQGlS5k2dfoUatMAU6lWJXAVa1atW7l21RoAbFixBMiWNXsWbVq1ZwO0dfuWQFy5c+nWtXuXbgC9e/kS8PsXcGDBgwkHDnAYcWICixk3/3b8GHJkxwEoV7ZMAHNmzZs5d/a8OUBo0aMJlDZ9GnVq1atRB3D9GjYB2bNp17Z9G3ftALt59ybwG3hw4cOJFxceAHly5QSYN3f+HHp06c8DVLd+nUB27du5d/f+nXsA8ePJEzB/Hn169evZpw/wHn58AvPp17d/H39++wH49/cPkIDAgQQLGjyIsGCAhQwbEngIMaLEiRQrSgyAMaNGAhw7evwIMqTIjwFKmjxJIKXKlSxbunzJMoDMmTQJ2LyJM6fOnTxzBvgJNCiBoUSLGj2KNKnRAEybOiUANarUqVSrWp0aIKvWrQS6ev0KNqzYsWADmD2LloDatWzbun0Lt/9tgLl06xK4izev3r18++oNADiwYAKECxs+jDix4sMBGjt+TCCy5MmUK1u+TDmA5s2cCXj+DDq06NGkQwc4jTo1gdWsW7t+DTu26wC0a9smgDu37t28e/veHSC48OEEihs/jjy58uXIAzh/Dp2A9OnUq1u/jr16gO3cuxP4Dj68+PHky4sPgD69egLs27t/Dz++/PcB6tu/TyC//v38+/sHSEDgQIIDAxxEmJDAQoYNHT6EGNFhAIoVLRLAmFHjRo4dPW4MEFLkSAIlTZ5EmVLlSpQBXL6ESUDmTJo1bd7EWTPATp49CfwEGlToUKJFhQZAmlQpAaZNnT6FGlXq0wD/Va1eJZBV61auXb1+5RpA7FiyBMyeRZtW7Vq2aQO8hRuXwFy6de3exZvXbgC+ff0SABxY8GDChQ0PDpBY8WICjR0/hhxZ8mTIASxfxkxA82bOnT1/Bt05wGjSpQmcRp1a9WrWrVUHgB1bNgHatW3fxp1b9+0AvX3/JhBc+HDixY0fJx5A+XLmBJw/hx5dOgDq1a1fvx5A+3buALx/Bx8+PAEA5c2fR48+wHr27QG8hx9fvnwCAOzfx58/fwD+/f0DBCBwIMGCBQkASKhwIUOGAQIMEDBAwAABAQIAyKhxI0eOBACADCly5MgAAgYIGCBggIABAQDAjClz5kwCAG7i/8ypU+cAAQMEDBAwQMAAAQCOIk2qVCkBAE6fQo0aVcAAAQMEDBAwQMAAAF6/gg0blgCAsmbPokU7QMAAAQMEDBAwQACAunbv4sVLAADfvn7//hUwQMAAAQMEDBAwAADjxo4fPyYAYDLlypYtDxAwQMAAAQMEDBAAYDTp0qZNEwCgejXr1q0DDBAwQMAAAQMEBACgezfv3r0JAAgufDhx4gECCBggYICAAQECAIgufTp16gQAYM+ufTt37QG+fwcgfjz58uUJAEivfj379u7fw2dPAAD9+vbv48+vf/99AgAAAhA4kGBBgwcRJlS4kGHDhAQARJQ4kWJFixcxUiQAgJVjR48fQYYUOfIjAQAnUaZUuZJlS5cqCQCQOZNmTZs3ceasSQBAT58/gQYVOpQoUAIAkCZVupRpU6dPlxIAMJVqVatXsWbVapUAAK9fwYYVO5Zs2bAEAKRVu5ZtW7dv4bIlAIBuXbt38ebVu/cuAQB/AQcWPJhwYcOCCQBQvJhxY8ePIUduTABAZcuXMWfWvJkzZgIBAQAh/wtORVRTQ0FQRTIuMAMBAAAALCUBrAAKAH4AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAiiAAkIFBigoMGDCBMqXMiwocOHECNKnEixosWLGDNq3Mixo8ePIEOKHEmypMmTKFOqXMmypcuXMGPKBDlAwAABAwQE2ClggIABAgYIGBAgwAABAwQMEDBAwAABAwQMEDBAwAABAwYIGCBggIABAgYIEDBAwAABAwQMEDAgwAABAwQMEDBAwIAAAgYIGCBggIABAQIPEDBAwAABARIrDgCgceOAACH/C05FVFNDQVBFMi4wAwEAAAAsJQGsAAoAfgCCAAAAzJlmZmbMmZnM////AAAAAAAAAAAACKcAAwgUSKBgwQAIEypcyLChw4cQI0qcSLGixYsYM2rcyLGjx48gQ4ocSbKkyZMoU6pcybKly5cwY8qcSbOmxwECBggYICCATwEDBAwQMEDAgAADBAwQMEDAAAEDAggYIGCAgAECBggIMEDAAAEDBAwQMECAgAECBggYIGCAgAADBAwQMEDAAAEDAgQYIGCAgAECBggIQFjAAAEDBAwIEACAY8cBIkcOCAAh/wtORVRTQ0FQRTIuMAMBAAAALCUBrAAKAH4AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAihAAkIHEgwgMGDCBMqXMiwocOHECNKnEixosWLGDNq3Mixo8ePIEOKHEmypMmTKFOqXMmypcuXMGPKnMlxgIABAgYICMBTwAABAwQMEDAgwAABAwQMEDBAwIAAAgYIGCBggIABAgYMEDBAwAABAwQMECBggIABAgYIGCBgwAABAwQMEDBAwIAAAQYIGCBggIABAgIIFjBAwAABAwIoXsxYcUAAIf8LTkVUU0NBUEUyLjADAQAAACwlAawACgB+AIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAIogAJCBQYoKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPHjyBDihxJsqTJkyhTqlzJsqXLlzBjygQ5QMAAAQMEBNgpYICAAQIGCBgQIMAAAQMEDBAwQMAAAQMEDBAwQMAAAQMGCBggYICAAQIGCBAwQMAAAQMEDBAwIMAAAQMEDBAwQMCAAAIGCBggYICAAQECDxAwQMAAAQESKw4AoHHjgAAh/wtORVRTQ0FQRTIuMAMBAAAALBABrAAzAI8AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIHEiwoMEACAMQWMiwocOHECNKXBigosWLBDJq3Mixo8ePHAOIHEmSgMmTKFOqXMkyZYCXMGMSmEmzps2bOHPaDMCzp08CQIMKHUq0qNGhAZIqXUqgqdOnUKNKnQo1gNWrWAlo3cq1q9evYLsGGEu2LIGzaNOqXcu2rdoAcOPKJUC3rt27ePPqvRugr9+/BAILHky4sOHDhAMoXsyYgOPHkCNLnkw5coDLmDMT2My5s+fPoEN7DkC6tGkCqFOrXs26tevVAWLLnk2gtu3buHPr3o07gO/fwAkIH068uPHjyIsHWM68OYHn0KNLn069uvQA2LNrJ8C9u/fv4MOL//8eoLz58wTSq1/Pvr379+wDyJ9Pn4D9+/jz69/PP38AgAEEDhxIwOBBhAkVLmSYMMBDiBEJTKRY0eJFjBktBuDY0SMBkCFFjiRZ0uTIAClVriTQ0uVLmDFlzoQZwOZNnAR07uTZ0+dPoD0DDCValMBRpEmVLmXaVGkAqFGlEqBa1epVrFm1Xg3Q1etXAmHFjiVb1uxZsgHUrmVLwO1buHHlzqUbN8BdvHkJ7OXb1+9fwIH9BiBc2DABxIkVL2bc2PHiAJElTyZQ2fJlzJk1b8YcwPNn0AREjyZd2vRp1KUDrGbdmsBr2LFlz6ZdW3YA3Ll1E+Dd2/dv4MGF/w5Q3P/4cQLJlS9n3tz5c+YBpE+nTsD6dezZtW/nnj3Ad/DhCYwnX978efTpzQdg3949Afjx5c+nX9/+/AD59e8n0N8/QAICBxIsaPDgwQAKFzIk4PAhxIgSJ1KMGOAixowENnLs6PEjyJAeA5AsaZIAypQqV7Js6XJlgJgyZxKoafMmzpw6d+IM4PMnUAJChxItavQo0qIBljJtSuAp1KhSp1KtKjUA1qxaCXDt6vUr2LBivwYoa/YsgbRq17Jt6/Yt2wBy59IlYPcu3rx69/LNG+Av4MAEBhMubPgw4sSGAzBu7JgA5MiSJ1OubHlygMyaNxPo7Pkz6NCiR4MOYPo0agL/qlezbu36NezWAWbTrk3gNu7cunfz7q07APDgwgkQL278OPLkyo8HaO78OYHo0qdTr279OvUA2rdzJ+D9O/jw4seTDx/gPPr0BNazb+/+Pfz47gPQr2+fAP78+vfz7+8fIAGBAgMUNHiQQEKFCxk2dPiQYQCJEykSsHgRY0aNGzlmDPARZEgCI0mWNHkSZUqTAVi2dEkAZkyZM2nWtDkzQE6dOwn09PkTaFChQ4EGMHoUKQGlS5k2dfoUatMAU6lWJXAVa1atW7l21RoAbFixBMiWNXsWbVq1ZwO0dfuWQFy5c+nWtXuXbgC9e/kS8PsXcGDBgwkHDnAYcWICixk3/3b8GHJkxwEoV7ZMAHNmzZs5d/a8OUBo0aMJlDZ9GnVq1atRB3D9GjYB2bNp17Z9GzftALt59ybwG3hw4cOJFxceAHly5QSYN3f+HHp06c8DVLd+nUB27du5d/f+nXsA8ePJEzB/Hn169evZpw/wHn58AvPp17d/H39++wH49/cPkIDAgQQLGjyIsGCAhQwbEngIMaLEiRQrSgyAMaNGAhw7evwIMqTIjwFKmjxJIKXKlSxbunzJMoDMmTQJ2LyJM6fOnTxzBvgJNCiBoUSLGj2KNKnRAEybOiUANarUqVSrWp0aIKvWrQS6ev0KNqzYsWADmD2LloDatWzbun0Lt/9tgLl06xK4izev3r18++oNADiwYAKECxs+jDix4sMBGjt+TCCy5MmUK1u+TDmA5s2cCXj+DDq06NGkQwc4jTo1gdWsW7t+DTu26wC0a9smgDu37t28e/veHSC48OEEihs/jjy58uXIAzh/Dp2A9OnUq1u/jr16gO3cuxP4Dj68+PHky4sPgD69egLs27t/Dz++/PcB6tu/TyC//v38+/sHSEDgQIIDAxxEmJDAQoYNHT6EGNFhAIoVLRLAmFHjRo4dPW4MEFLkSAIlTZ5EmVLlSpQBXL6ESUDmTJo1bd7EWTPATp49CfwEGlToUKJFhQZAmlQpAaZNnT6FGlXq0wD/Va1eJZBV61auXb1+5RpA7FiyBMyeRZtW7Vq2aQO8hRuXwFy6de3exZvXbgC+ff0SABxY8GDChQ0PDpBY8WICjR0/hhxZ8mTIASxfxkxA82bOnT1/Bt05wGjSpQmcRp1a9WrWrVUHgB1bNgHatW3fxp1b9+0AvX3/JhBc+HDixY0fJx5A+XLmBJw/hx5dOgDq1a1fvx5A+3buALx/Bx8+PAEA5c2fR48+wHr27QG8hx9fvnwCAOzfx58/fwD+/f0DBCBwIMGCBQkASKhwIUOGAQIMEDBAwAABAQIAyKhxI0eOBACADCly5MgAAgYIGCBggIABAQDAjClz5kwCAG7i/8ypU2eAAQIGCBggYICAAQCOIk2qVCkBAE6fQo0aVcAAAQMEDBAwQMAAAF6/gg0blgCAsmbPokU7QMAAAQMEDBAwQACAunbv4sVLAADfvn7//hUwQMAAAQMEDBAwAADjxo4fPyYAYDLlypYtBxggYICAAQIGCBgAYDTp0qZNEwCgejXr1q0DCBggYICAAQIGBACgezfv3r0JAAgufDhx4gECDBAwQMAAAQECAIgufTp16gQAYM+ufTt37QG+fwcgfjz58uUJAEivfj379u7fw2dPAAD9+vbv48+vf/99AgAAAhA4kGBBgwcRJlS4kGHDhAQARJQ4kWJFixcxUiQAgJVjR48fQYYUOfIjAQAnUaZUuZJlS5cqCQCQOZNmTZs3ceasSQBAT58/gQYVOpQoUAIAkCZVupRpU6dPlxIAMJVqVatXsWbVapUAAK9fwYYVO5Zs2bAEAKRVu5ZtW7dv4bIlAIBuXbt38ebVu/cuAQB/AQcWPJhwYcOCCQBQvJhxY8ePIUduTABAZcuXMWfWvJkzZgIBAQAh/wtORVRTQ0FQRTIuMAMBAAAALBABrAAzAI8AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIHEiwoMGCARIGIMCwocOHECNKfBigosWLBDJq3Mixo8ePHAOIHEmSgMmTKFOqXMkyZYCXMGMSmEmzps2bOHPaDMCzp08CQIMKHUq0qNGhAZIqXUqgqdOnUKNKnQo1gNWrWAlo3cq1q9evYLsGGEu2LIGzaNOqXcu2rdoAcOPKJUC3rt27ePPqvRugr9+/BAILHky4sOHDhAMoXsyYgOPHkCNLnkw5coDLmDMT2My5s+fPoEN7DkC6tGkCqFOrXs26tevVAWLLnk2gtu3buHPr3o07gO/fwAkIH068uPHjyIsHWM68OYHn0KNLn069uvQA2LNrJ8C9u/fv4MOL//8eoLz58wTSq1/Pvr379+wDyJ9Pn4D9+/jz69/PP38AgAEEDhxIwOBBhAkVLmSYMMBDiBEJTKRY0eJFjBktBuDY0SMBkCFFjiRZ0uTIAClVriTQ0uVLmDFlzoQZwOZNnAR07uTZ0+dPoD0DDCValMBRpEmVLmXaVGkAqFGlEqBa1epVrFm1Xg3Q1etXAmHFjiVb1uxZsgHUrmVLwO1buHHlzqUbN8BdvHkJ7OXb1+9fwIH9BiBc2DABxIkVL2bc2PHiAJElTyZQ2fJlzJk1b8YcwPNn0AREjyZd2vRp1KUDrGbdmsBr2LFlz6ZdW3YA3Ll1E+Dd2/dv4MGF/w5Q3P/4cQLJlS9n3tz5c+YBpE+nTsD6dezZtW/nnj3Ad/DhCYwnX978efTpzQdg3949Afjx5c+nX9/+/AD59e8n0N8/QAICBxIsaPDgwQAKFzIk4PAhxIgSJ1KMGOAixowENnLs6PEjyJAeA5AsaZIAypQqV7Js6XJlgJgyZxKoafMmzpw6d+IM4PMnUAJChxItavQo0qIBljJtSuAp1KhSp1KtKjUA1qxaCXDt6vUr2LBivwYoa/YsgbRq17Jt6/Yt2wBy59IlYPcu3rx69/LNG+Av4MAEBhMubPgw4sSGAzBu7JgA5MiSJ1OubHlygMyaNxPo7Pkz6NCiR4MOYPo0agL/qlezbu36NezWAWbTrk3gNu7cunfz7q07APDgwgkQL278OPLkyo8HaO78OYHo0qdTr279OvUA2rdzJ+D9O/jw4seTDx/gPPr0BNazb+/+Pfz47gPQr2+fAP78+vfz7+8fIAGBAgMUNHiQQEKFCxk2dPiQYQCJEykSsHgRY0aNGzlmDPARZEgCI0mWNHkSZUqTAVi2dEkAZkyZM2nWtDkzQE6dOwn09PkTaFChQ4EGMHoUKQGlS5k2dfoUqtMAU6lWJXAVa1atW7l21RoAbFixBMiWNXsWbVq1ZwO0dfuWQFy5c+nWtXuXbgC9e/kS8PsXcGDBgwkHDnAYcWICixk3/3b8GHJkxwEoV7ZMAHNmzZs5d/a8OUBo0aMJlDZ9GnVq1atRB3D9GjYB2bNp17Z9G3ftALt59ybwG3hw4cOJFxceAHly5QSYN3f+HHp06c8DVLd+nUB27du5d/f+nXsA8ePJEzB/Hn169evZpw/wHn58AvPp17d/H39++wH49/cPkIDAgQQLGjyIsGCAhQwbEngIMaLEiRQrSgyAMaNGAhw7evwIMqTIjwFKmjxJIKXKlSxbunzJMoDMmTQJ2LyJM6fOnTxzBvgJNCiBoUSLGj2KNKnRAEybOiUANarUqVSrWp0aIKvWrQS6ev0KNqzYsWADmD2LloDatWzbun0Lt/9tgLl06xK4izev3r18++oNADiwYAKECxs+jDix4sMBGjt+TCCy5MmUK1u+TDmA5s2cCXj+DDq06NGkQwc4jTo1gdWsW7t+DTu26wC0a9smgDu37t28e/veHSC48OEEihs/jjy58uXIAzh/Dp2A9OnUq1u/jr16gO3cuxP4Dj68+PHky4sPgD69egLs27t/Dz++/PcB6tu/TyC//v38+/sHSEDgQIIDAxxEmJDAQoYNHT6EGNFhAIoVLRLAmFHjRo4dPW4MEFLkSAIlTZ5EmVLlSpQBXL6ESUDmTJo1bd7EWTPATp49CfwEGlToUKJFhQZAmlQpAaZNnT6FGlXq0wD/Va1eJZBV61auXb1+5RpA7FiyBMyeRZtW7Vq2aQO8hRuXwFy6de3exZvXbgC+ff0SABxY8GDChQ0PDpBY8WICjR0/hhxZ8mTIASxfxkxA82bOnT1/Bt05wGjSpQmcRp1a9WrWrVUHgB1bNgHatW3fxp1b9+0AvX3/JhBc+HDixY0fJx5A+XLmBJw/hx5dOgDq1a1fvx5A+3buALx/Bx8+PAEA5c2fR48+wHr27QG8hx9fvnwCAOzfx58/fwD+/f0DBCBwIMGCBQkASKhwIUOGAQIMEDBAwAABAQIAyKhxI0eOBACADCly5MgAAgYIGCBggIABAQDAjClz5kwCAG7i/8ypU+cAAQMEDBAwQMCAAACOIk2qVCkBAE6fQo0aVcAAAQMEDBAwQMAAAF6/gg0blgCAsmbPokU7QMAAAQMEDBAwQACAunbv4sVLAADfvn7//hUwQMAAAQMEDBAwAADjxo4fPyYAYDLlypYtDxAwQMAAAQMEDAgAYDTp0qZNEwCgejXr1q0DDBAwQMAAAQMEBACgezfv3r0JAAgufDhx4gECCBggYICAAQECAIgufTp16gQAYM+uffv2AN69Awgvfjz58uMJAEivfj379u7fw2dPAAD9+vbv48+vfz///v4BAhA4kGBBgwIJAFC4kGFDhw8hRmxIAEBFixcxZtS4kZgjRgIAQIYUOZJkSZMnRxIAsJJlS5cvYcaU6ZIAAJs3cebUuZNnz5wEAAQVOpRoUaNHkRIlAIBpU6dPoUaVOvUpAQBXsWbVupVrV69aCQAQO5ZsWbNn0aYtSwBAW7dv4caVO5cuXAIA8ObVu5dvX79/9xIAMJhwYcOHESdWbJgAAMePIUeWPJly5cgEAGTWvJlzZ8+fQXMOCAAh/wtORVRTQ0FQRTIuMAMBAAAALBABrAAzAI8AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIHEiwYMEACBESWMiwocOHECNKJBCgosWLBDJq3Mixo8ePHAOIHEmSgMmTKFOqXMkyZYCXMGMSmEmzps2bOHPaDMCzp08CQIMKHUq0qNGhAZIqXUqgqdOnUKNKnQo1gNWrWAlo3cq1q9evYLsGGEu2LIGzaNOqXcu2rdoAcOPKJUC3rt27ePPqvRugr9+/BAILHky4sOHDhAMoXsyYgOPHkCNLnkw5coDLmDMT2My5s+fPoEN7DkC6tGkCqFOrXs26tevVAWLLnk2gtu3buHPr3o07gO/fwAkIH068uPHjyIsHWM68OYHn0KNLn069uvQA2LNrJ8C9u/fv4MOL//8eoLz58wTSq1/Pvr379+wDyJ9Pn4D9+/jz69/PP38AgAEEDhxIwOBBhAkVLmSYMMBDiBEJTKRY0eJFjBktBuDY0SMBkCFFjiRZ0uTIAClVriTQ0uVLmDFlzoQZwOZNnAR07uTZ0+dPoD0DDCValMBRpEmVLmXaVGkAqFGlEqBa1epVrFm1Xg3Q1etXAmHFjiVb1uxZsgHUrmVLwO1buHHlzqUbN8BdvHkJ7OXb1+9fwIH9BiBc2DABxIkVL2bc2PHiAJElTyZQ2fJlzJk1b8YcwPNn0AREjyZd2vRp1KUDrGbdmsBr2LFlz6ZdW3YA3Ll1E+Dd2/dv4MGF/w5Q3P/4cQLJlS9n3tz5c+YBpE+nTsD6dezZtW/nnj3Ad/DhCYwnX978efTpzQdg3949Afjx5c+nX9/+/AD59e8n0N8/QAICBxIsaPDgwQAKFzIk4PAhxIgSJ1KMGOAixowENnLs6PEjyJAeA5AsaZIAypQqV7Js6XJlgJgyZxKoafMmzpw6d+IM4PMnUAJChxItavQo0qIBljJtSuAp1KhSp1KtKjUA1qxaCXDt6vUr2LBivwYoa/YsgbRq17Jt6/Yt2wBy59IlYPcu3rx69/LNG+Av4MAEBhMubPgw4sSGAzBu7JgA5MiSJ1OubHlygMyaNxPo7Pkz6NCiR4MOYPo0agL/qlezbu36NezWAWbTrk3gNu7cunfz7q07APDgwgkQL278OPLkyo8HaO78OYHo0qdTr279OvUA2rdzJ+D9O/jw4seTDx/gPPr0BNazb+/+Pfz47gPQr2+fAP78+vfz7+8fIAGBAgMUNHiQQEKFCxk2dPiQYQCJEykSsHgRY0aNGzlmDPARZEgCI0mWNHkSZUqTAVi2dEkAZkyZM2nWtDkzQE6dOwn09PkTaFChQ4EGMHoUKQGlS5k2dfoUatMAU6lWJXAVa1atW7l21RoAbFixBMiWNXsWbVq1ZwO0dfuWQFy5c+nWtXuXbgC9e/kS8PsXcGDBgwkHDnAYcWICixk3/3b8GHJkxwEoV7ZMAHNmzZs5d/a8OUBo0aMJlDZ9GnVq1atRB3D9GjYB2bNp17Z9G3ftALt59ybwG3hw4cOJFxceAHly5QSYN3f+HHp06c8DVLd+nUB27du5d/f+nXsA8ePJEzB/Hn169evZpw/wHn58AvPp17d/H39++wH49/cPkIDAgQQLGjyIsGCAhQwbEngIMaLEiRQrSgyAMaNGAhw7evwIMqTIjwFKmjxJIKXKlSxbunzJMoDMmTQJ2LyJM6fOnTxzBvgJNCiBoUSLGj2KNKnRAEybOiUANarUqVSrWp0aIKvWrQS6ev0KNqzYsWADmD2LloDatWzbun0Lt/9tgLl06xK4izev3r18++oNADiwYAKECxs+jDix4sMBGjt+TCCy5MmUK1u+TDmA5s2cCXj+DDq06NGkQwc4jTo1gdWsW7t+DTu26wC0a9smgDu37t28e/veHSC48OEEihs/jjy58uXIAzh/Dp2A9OnUq1u/jr16gO3cuxP4Dj68+PHky4sPgD69egLs27t/Dz++/PcB6tu/TyC//v38+/sHSEDgQIIDAxxEmJDAQoYNHT6EGNFhAIoVLRLAmFHjRo4dPW4MEFLkSAIlTZ5EmVLlSpQBXL6ESUDmTJo1bd7EWTPATp49CfwEGlToUKJFhQZAmlQpAaZNnT6FGlXq0wD/Va1eJZBV61auXb1+5RpA7FiyBMyeRZtW7Vq2aQO8hRuXwFy6de3exZvXbgC+ff0SABxY8GDChQ0PDpBY8WICjR0/hhxZ8mTIASxfxkxA82bOnT1/Bt05wGjSpQmcRp1a9WrWrVUHgB1bNgHatW3fxp1b9+0AvX3/JhBc+HDixY0fJx5A+XLmBJw/hx5dOgDq1a1fvx5A+3buALx/Bx8+PAEA5c2fR48+wHr27QG8hx9fvnwCAOzfx58/fwD+/f0DBCBwIMGCBQkASKhwIUOGAQIMEDBAwAABAQIAyKhxI0eOBACADCly5MgAAgYIGCBggIABAQDAjClz5kwCAG7i/8ypU+cAAQMEDBAwQMCAAACOIk2qVCkBAE6fQo0aVcAAAQMEDBAwQMAAAF6/gg0blgCAsmbPokU7QMAAAQMEDBAwQACAunbv4sVLAADfvn7//hUwQMAAAQMEDBAwAADjxo4fPyYAYDLlypYtDxAwQMAAAQMEDAgAYDTp0qZNEwCgejXr1q0DDBAwQMAAAQMEBACgezfv3r0JAAgufDhx4gECCBggYICAAQECAIgufTp16gQAYM+ufTt37QG+fwcgfjz58uUJAEivfj379u7fw2dPAAD9+vbv48+vf/99AgAAAhA4kGBBgwcRJlS4kGHDhAQARJQ4kWJFixcxUiQAgJVjR48fQYYUOfIjAQAnUaZUuZJlS5cqCQCQOZNmTZs3ceasSQBAT58/gQYVOpQoUAIAkCZVupRpU6dPlxIAMJVqVatXsWbVapUAAK9fwYYVO5Zs2bAEAKRVu5ZtW7dv4bIlAIBuXbt38ebVu/cuAQB/AQcWPJhwYcOCCQBQvJhxY8ePIUduTABAZcuXMWfWvJkzZgIBAQAh/wtORVRTQ0FQRTIuMAMBAAAALCQBrAAKAH4AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAihAAkIHEgwgMGDCBMqXMiwocOHECNKnEixosWLGDNq3Mixo8ePIEOKHEmypMmTKFOqXMmypcuXMGPKnMlxgIABAgYICMBTwAABAwQMEDAgQIABAgYIGCBggIABAgYIGCBggIABAgYMEDBAwAABAwQMECBggIABAgYIGCBgQIABAgYIGCBggIABAQQMEDBAwAABAwIIHiBggIABAgIoXsxYcUAAIf8LTkVUU0NBUEUyLjADAQAAACwpAawABQB+AIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAIYAAJBBhIsKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPHjyBDipwoYICAAAEEDBAwIMAAAQMEDBggYICAAQIGCBggYICAAQIGDBAwQMAAAQMEDAggYICAAAEASJUaEAAh/wtORVRTQ0FQRTIuMAMBAAAALCQBrAAKAH4AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAinAAMIFEigYMEACBMqXMiwocOHECNKnEixosWLGDNq3Mixo8ePIEOKHEmypMmTKFOqXMmypcuXMGPKnEmzpscBAgYIGCAggE8BAwQMEDBAwIAAAwQMEDBAwAABAwIIGCBggIABAgYIGDBAwAABAwQMEDBAgIABAgYIGCBggIABAwQMEDBAwAABAwIEGCBggIABAgYICEBYwAABAwQMCBAAgGPHASJHDggAIf8LTkVUU0NBUEUyLjADAQAAACwkAawABQB+AIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAIYAAJCBQYoKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPHjyBDihxJcuIAAQMCCBggYMAAAQMEDBAwQMAAAQMEDBAwQMAAAQMEDBAwQMCAAAMEDBAQIICAAQICSJUaEAAh/wtORVRTQ0FQRTIuMAMBAAAALA8BrAAzAI8AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIHEiwoMEACAMQWMiwocOHECNKXBigosWLBDJq3Mixo8ePHAOIHEmSgMmTKFOqXMkyZYCXMGMSmEmzps2bOHPaDMCzp08CQIMKHUq0qNGhAZIqXUqgqdOnUKNKnQo1gNWrWAlo3cq1q9evYLsGGEu2LIGzaNOqXcu2rdoAcOPKJUC3rt27ePPqvRugr9+/BAILHky4sOHDhAMoXsyYgOPHkCNLnkw5coDLmDMT2My5s+fPoEN7DkC6tGkCqFOrXs26tevVAWLLnk2gtu3buHPr3o07gO/fwAkIH068uPHjyIsHWM68OYHn0KNLn069uvQA2LNrJ8C9u/fv4MOL//8eoLz58wTSq1/Pvr379+wDyJ9Pn4D9+/jz69/PP38AgAEEDhxIwOBBhAkVLmSYMMBDiBEJTKRY0eJFjBktBuDY0SMBkCFFjiRZ0uTIAClVriTQ0uVLmDFlzoQZwOZNnAR07uTZ0+dPoD0DDCValMBRpEmVLmXaVGkAqFGlEqBa1epVrFm1Xg3Q1etXAmHFjiVb1uxZsgHUrmVLwO1buHHlzqUbN8BdvHkJ7OXb1+9fwIH9BiBc2DABxIkVL2bc2PHiAJElTyZQ2fJlzJk1b8YcwPNn0AREjyZd2vRp1KUDrGbdmsBr2LFlz6ZdW3YA3Ll1E+Dd2/dv4MGF/w5Q3P/4cQLJlS9n3tz5c+YBpE+nTsD6dezZtW/nnj3Ad/DhCYwnX978efTpzQdg3949Afjx5c+nX9/+/AD59e8n0N8/QAICBxIsaPDgwQAKFzIk4PAhxIgSJ1KMGOAixowENnLs6PEjyJAeA5AsaZIAypQqV7Js6XJlgJgyZxKoafMmzpw6d+IM4PMnUAJChxItavQo0qIBljJtSuAp1KhSp1KtKjUA1qxaCXDt6vUr2LBivwYoa/YsgbRq17Jt6/Yt2wBy59IlYPcu3rx69/LNG+Av4MAEBhMubPgw4sSGAzBu7JgA5MiSJ1OubHlygMyaNxPo7Pkz6NCiR4MOYPo0agL/qlezbu36NezWAWbTrk3gNu7cunfz7q07APDgwgkQL278OPLkyo8HaO78OYHo0qdTr279OvUA2rdzJ+D9O/jw4seTDx/gPPr0BNazb+/+Pfz47gPQr2+fAP78+vfz7+8fIAGBAgMUNHiQQEKFCxk2dPiQYQCJEykSsHgRY0aNGzlmDPARZEgCI0mWNHkSZUqTAVi2dEkAZkyZM2nWtDkzQE6dOwn09PkTaFChQ4EGMHoUKQGlS5k2dfoUatMAU6lWJXAVa1atW7l21RoAbFixBMiWNXsWbVq1ZwO0dfuWQFy5c+nWtXuXbgC9e/kS8PsXcGDBgwkHDnAYcWICixk3/3b8GHJkxwEoV7ZMAHNmzZs5d/a8OUBo0aMJlDZ9GnVq1atPB3D9GnYAArNp17Z9G3fu2gF49/ZNAHhw4cOJFzc+PEBy5csJNHf+HHp06dOhB7B+HTsB7du5d/f+HXz3AOPJlydwHn169evZt1cfAH58+QTo17d/H39+/fcD9PcPMIDAAAQKGjyIMKHChQgDOHwIkYDEiRQrWryIsWKAjRw7EvgIMqTIkSRLigyAMqVKAixbunwJM6bMlwFq2rxJIKfOnTx7+vzJM4DQoUQJGD2KNKnSpUyTBngKNSqBqVSrWr2KNavVAFy7eiUANqzYsWTLmh0bIK3atQTaun0LN/+u3LlwA9i9i5eA3r18+/r9C7hvgMGECxM4jDix4sWMGysOADmyZAKUK1u+jDmz5ssBOnv+TCC06NGkS5s+TTqA6tWsCbh+DTu27Nm0Ywe4jTs3gd28e/v+DTy47wDEixsngDy58uXMmztfHiC69OkEqlu/jj279u3YA3j/Dp6A+PHky5s/j758gPXs2xN4Dz++/Pn068sPgD+/fgL8+/sHSEDgQIIFDR4cGEDhQoYEHD6EGFHiRIoRA1zEmJHARo4dPX4EGdJjAJIlTRJAmVLlSpYtXa4MEFPmTAI1bd7EmVPnTpwBfP4ESkDoUKJFjR5FWjTAUqZNCTyFGlXqVKr/VaUGwJpVKwGuXb1+BRtW7NcAZc2eJZBW7Vq2bd2+ZRtA7ly6BOzexZtX716+eQP8BRyYwGDChQ0fRpzYcADGjR0TgBxZ8mTKlS1PDpBZ82YCnT1/Bh1a9GjQAUyfRk1A9WrWrV2/ht06wGzatQncxp1b927evXUHAB5cOAHixY0fR55c+fEAzZ0/JxBd+nTq1QFcx55du/YA3b1/BxBe/Hjy5AkAQJ9e/fr1Ady/hw9A/nz69esTAJBf/37+/AMADCBw4EAABg8iTJiQAICGDh9ChBggwAABAwQMEBAgAICOHj+CBEkAAMmSJk+eDCBggIABAgYIGBAAAM2aNm/e/yQAYCfPnj59BhggYICAAQIGCBgAYCnTpk6dEgAgdSrVqlUFDBAwQMAAAQMEDAAgdizZsmUJAEirdi1btgMEDBAwQMAAAQMEAMirdy9fvgQAAA4sePBgAQMEDBAwQMAAAQMAQI4sefJkAgAuY86sWXOAAQIGCBggYICAAQBOo06tWjUBAK5fw44dO4CAAQIGCBggYEAAAL5/Aw8enACA4saPI0ceIMAAAQMEDBAQIACA6tavY8dOAAD37t6/g/ceYPx4AObPo0+fngCA9u7fw48vfz59+AQA4M+vfz///v4BAhA4kCBBAgAQJlS4kGFDhw8hRpQ4ESIBABcxZtS4kZtjR48aCQAQOZJkSZMnUaYsSQBAS5cvYcaUOZMmTAIAcObUuZNnT58/dxIAMJRoUaNHkSZVapQAAKdPoUaVOpVq1agEAGTVupVrV69fwXIlAIBsWbNn0aZVu/YsAQBv4caVO5duXbtyCQDQu5dvX79/AQfuSwBAYcOHESdWvJgxYgIAIEeWPJlyZcuXJxMAsJlzZ8+fQYcW7ZlAQAAh/wtORVRTQ0FQRTIuMAMBAAAALCMB8wALADUAggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkEGEiwIIEACBMqJBCgocOHBAJInEiRQICLGDMSCMCxo0cCAUKKHEkggMmTKAkEWMmyJYEAMGPKJBCgps2bBALo3MmTQICfQIMSCEC0qFECAZIqXUoggNOnUAkEmEq1qlWrBAJo3cqVQICvYMMSCEC2rFkCAdKqXUsggNu3cAkEmEu3LoEAePPqJRCgr9+/BAIIHkyYQIDDiBMTCMC4sWMCASJLnkwggOXLmAkE2My5M4EAoEOLJhCgtOnTBAKoXs2aQIDXsGMTCEC7tm0CAXLr3k0ggO/fwAkEGE68OIEAyJMrJxCgufPnBAJIn04dQIDr2LMDCMC9u3cAAQIMYxAwQMAAAQECAAggYICAAQIGCBgQAECAAQIGCBggYIAAgAMABBAwQMAAAQMEDBAAYICAAQIGCBggYIAAAAEGCBggYICAAQIGAAggYICAAQIGCBggAECAAQIGCBggYICAAAACAgAh/wtORVRTQ0FQRTIuMAMBAAAALA8BrAAzAI8AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIHEiwoMGCARIGIMCwocOHECNKfBigosWLBDJq3Mixo8ePHAOIHEmSgMmTKFOqXMkyZYCXMGMSmEmzps2bOHPaDMCzp08CQIMKHUq0qNGhAZIqXUqgqdOnUKNKnQo1gNWrWAlo3cq1q9evYLsGGEu2LIGzaNOqXcu2rdoAcOPKJUC3rt27ePPqvRugr9+/BAILHky4sOHDhAMoXsyYgOPHkCNLnkw5coDLmDMT2My5s+fPoEN7DkC6tGkCqFOrXs26tevVAWLLnk2gtu3buHPr3o07gO/fwAkIH068uPHjyIsHWM68OYHn0KNLn069uvQA2LNrJ8C9u/fv4MOL//8eoLz58wTSq1/Pvr379+wDyJ9Pn4D9+/jz69/PP38AgAEEDhxIwOBBhAkVLmSYMMBDiBEJTKRY0eJFjBktBuDY0SMBkCFFjiRZ0uTIAClVriTQ0uVLmDFlzoQZwOZNnAR07uTZ0+dPoD0DDCValMBRpEmVLmXaVGkAqFGlEqBa1epVrFm1Xg3Q1etXAmHFjiVb1uxZsgHUrmVLwO1buHHlzqUbN8BdvHkJ7OXb1+9fwIH9BiBc2DABxIkVL2bc2PHiAJElTyZQ2fJlzJk1b8YcwPNn0AREjyZd2vRp1KUDrGbdmsBr2LFlz6ZdW3YA3Ll1E+Dd2/dv4MGF/w5Q3P/4cQLJlS9n3tz5c+YBpE+nTsD6dezZtW/nnj3Ad/DhCYwnX978efTpzQdg3949Afjx5c+nX9/+/AD59e8n0N8/QAICBxIsaPDgwQAKFzIk4PAhxIgSJ1KUGOAixowENnLs6PEjyJAeA5AsaZIAypQqV7Js6XJlgJgyZxKoafMmzpw6d+IM4PMnUAJChxItavQo0qIBljJtSuAp1KhSp1KtKjUA1qxaCXDt6vUr2LBivwYoa/YsgbRq17Jt6/Yt2wBy59IlYPcu3rx69/LNG+Av4MAEBhMubPgw4sSGAzBu7JgA5MiSJ1OubHlygMyaNxPo7Pkz6NCiR4MOYPo0agL/qlezbu36NezWAWbTrk3gNu7cunfz7q07APDgwgkQL278OPLkyo8HaO78OYHo0qdTr279OvUA2rdzJ+D9O/jw4seTDx/gPPr0BNazb+/+Pfz47gPQr2+fAP78+vfz7+8fIAGBAgMUNHiQQEKFCxk2dPiQYQCJEykSsHgRY0aNGzlmDPARZEgCI0mWNHkSZUqTAVi2dEkAZkyZM2nWtDkzQE6dOwn09PkTaFChQ4EGMHoUKQGlS5k2dfoUatMAU6lWJXAVa1atW7l21RoAbFixBMiWNXsWbVq1ZwO0dfuWQFy5c+nWtXuXbgC9e/kS8PsXcGDBgwkHDnAYcWICixk3/3b8GHJkxwEoV7ZMAHNmzZs5d/a8OUBo0aMJlDZ9GnVq1atRB3D9GjYB2bNp17Z9G3ftALt59ybwG3hw4cOJFxceAHly5QSYN3f+HHp06c8DVLd+nUB27du5d/f+nXsA8ePJEzB/Hn169evZpw/wHn58AvPp17d/H39++wH49/cPkIDAgQQLGjyIsGCAhQwbEngIMaLEiRQrSgyAMaNGAhw7evwIMqTIjwFKmjxJIKXKlSxbunzJMoDMmTQJ2LyJM6fOnTxzBvgJNCiBoUSLGj2KNKnRAEybOiUANarUqVSrWp0aIKvWrQS6ev0KNqzYsWADmD2LloDatWzbun0Lt/9tgLl06xK4izev3r18++oNADiwYAKECxs+jDix4sMBGjt+TCCy5MmUK1u+TDmA5s2cCXj+DDq06NGkQwc4jTo1gdWsW7t+DTu26wC0a9smgDu37t28e/veHSC48OEEihs/jjy58uXIAzh/Dp2A9OnUq1u/jr16gO3cuxP4Dj68+PHky4sPgD69egLs27t/Dz++/PcB6tu/TyC//v38+/sHSEDgQIIDAxxEmJDAQoYNHT6EGNFhAIoVLRLAmFHjRo4dPW4MEFLkSAIlTZ5EmVLlSpQBXL6ESUDmTJo1bd7EWTPATp49CfwEGlToUKJFhQZAmlQpAaZNnT6FGlXq0wD/Va1eJZBV61auXb1+5RpA7FiyBMyeRZtW7Vq2aQO8hRuXwFy6de3exZvXbgC+ff0SABxY8GDChQ0PDpBY8WICjR0/hhxZ8mTIASxfxkxA82bOnT1/Bt05wGjSpQmcRp1a9WrWrVUHgB1bNgHatW3fxp1b9+0AvX3/JhBc+HDixY0fJx5A+XLmBJw/hx5dOgDq1a1fvx5A+3buALx/Bx8+PAEA5c2fR48+wHr27QG8hx9fvnwCAOzfx58/fwD+/f0DBCBwIMGCBQkASKhwIUOGAQIMEDBAwAABAQIAyKhxI0eOBACADCly5MgAAgYIGCBggIABAQDAjClz5kwCAG7i/8ypU+cAAQMEDBAwQMCAAACOIk2qVCkBAE6fQo0aVcAAAQMEDBAwQMAAAF6/gg0blgCAsmbPokU7QMAAAQMEDBAwQACAunbv4sVLAADfvn7//hUwQMAAAQMEDBAwAADjxo4fPyYAYDLlypYtDxAwQMAAAQMEDAgAYDTp0qZNEwCgejXr1q0DDBAwQMAAAQMEBACgezfv3r0JAAgufDhx4gECCBggYICAAQECAIgufTp16gQAYM+uffv2AN69Awgvfjz58uMJAEivfj379u7fw2dPAAD9+vbv48+vfz///v4BAhA4kGBBgwIJAFC4kGFDhw8hRmxIAEBFixcxZtS4kZgjRgIAQIYUOZJkSZMnRxIAsJJlS5cvYcaU6ZIAAJs3cebUuZNnz5wEAAQVOpRoUaNHkRIlAIBpU6dPoUaVOvUpAQBXsWbVupVrV69aCQAQO5ZsWbNn0aYtSwBAW7dv4caVO5cuXAIA8ObVu5dvX79/9xIAMJhwYcOHESdWbJgAAMePIUeWPJly5cgEAGTWvJlzZ8+fQXMOCAAh/wtORVRTQ0FQRTIuMAMBAAAALA8BrAAzAI8AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIHEiwoMEACAMQWMiwocOHECNKXBigosWLBDJq3Mixo8ePHAOIHEmSgMmTKFOqXMkyZYCXMGMSmEmzps2bOHPaDMCzp08CQIMKHUq0qNGhAZIqXUqgqdOnUKNKnQo1gNWrWAlo3cq1q9evYLsGGEu2LIGzaNOqXcu2rdoAcOPKJUC3rt27ePPqvRugr9+/BAILHky4sOHDhAMoXsyYgOPHkCNLnkw5coDLmDMT2My5s+fPoEN7DkC6tGkCqFOrXs26tevVAWLLnk2gtu3buHPr3n07gO/fwAkIH068uPHjyIsHWM68OYHn0KNLn069uvQA2LNrJ8C9u/fv4MOL//8eoLz58wTSq1/Pvr379+wDyJ9Pn4D9+/jz69/PP38AgAEEDhxIwOBBhAkVLmSYMMBDiBEJTKRY0eJFjBktBuDY0SMBkCFFjiRZ0uTIAClVriTQ0uVLmDFlzoQZwOZNnAR07uTZ0+dPoD0DDCValMBRpEmVLmXaVGkAqFGlEqBa1epVrFm1Xg3Q1etXAmHFjiVb1uxZsgHUrmVLwO1buHHlzqUbN8BdvHkJ7OXb1+9fwIH9BiBc2DABxIkVL2bc2PHiAJElTyZQ2fJlzJk1b8YcwPNn0AREjyZd2vRp1KUDrGbdmsBr2LFlz6ZdW3YA3Ll1E+Dd2/dv4MGF/w5Q3P/4cQLJlS9n3tz5c+YBpE+nTsD6dezZtW/nnj3Ad/DhCYwnX978efTpzQdg3949Afjx5c+nX9/+/AD59e8n0N8/QAICBxIsaPDgwQAKFzIk4PAhxIgSJ1KMGOAixowENnLs6PEjyJAeA5AsaZIAypQqV7Js6XJlgJgyZxKoafMmzpw6d+IM4PMnUAJChxItavQo0qIBljJtSuAp1KhSp1KtKjUA1qxaCXDt6vUr2LBivwYoa/YsgbRq17Jt6/Yt2wBy59IlYPcu3rx69/LNG+Av4MAEBhMubPgw4sSGAzBu7JgA5MiSJ1OubHlygMyaNxPo7Pkz6NCiR4MOYPo0agL/qlezbu36NezWAWbTrk3gNu7cunfz7q07APDgwgkQL278OPLkyo8HaO78OYHo0qdTr279OvUA2rdzJ+D9O/jw4seTDx/gPPr0BNazb+/+Pfz47gPQr2+fAP78+vfz7+8fIAGBAgMUNHiQQEKFCxk2dPiQYQCJEykSsHgRY0aNGzlmDPARZEgCI0mWNHkSZUqTAVi2dEkAZkyZM2nWtDkzQE6dOwn09PkTaFChQ4EGMHoUKQGlS5k2dfoUatMAU6lWJXAVa1atW7l21RoAbFixBMiWNXsWbVq1ZwO0dfuWQFy5c+nWtXuXbgC9e/kS8PsXcGDBgwkHDnAYcWICixk3/3b8GHJkxwEoV7ZMAHNmzZs5d/a8OUBo0aMJlDZ9GnVq1atRB3D9GjYB2bNp17Z9G3ftALt59ybwG3hw4cOJFxceAHly5QSYN3f+HHp06c8DVLd+nUB27du5d/f+nXsA8ePJEzB/Hn169evZpw/wHn58AvPp17d/H39++wH49/cPkIDAgQQLGjyIsGCAhQwbEngIMaLEiRQrSgyAMaNGAhw7evwIMqTIjwFKmjxJIKXKlSxbunzJMoDMmTQJ2LyJM6fOnTxzBvgJNCiBoUSLGj2KNKnRAEybOiUANarUqVSrWp0aIKvWrQS6ev0KNqzYsWADmD2LloDatWzbun0Lt/9tgLl06xK4izev3r18++oNADiwYAKECxs+jDix4sMBGjt+TCCy5MmUK1u+TDmA5s2cCXj+DDq06NGkQwc4jTo1gdWsW7t+DTu26wC0a9smgDu37t28e/veHSC48OEEihs/jjy58uXIAzh/Dp2A9OnUq1u/jr16gO3cuxP4Dj68+PHky4sPgD69egLs27t/Dz++/PcB6tu/TyC//v38+/sHSEDgQIIDAxxEmJDAQoYNHT6EGNFhAIoVLRLAmFHjRo4dPW4MEFLkSAIlTZ5EmVLlSpQBXL6ESUDmTJo1bd7EWTPATp49CfwEGlToUKJFhQZAmlQpAaZNnT6FGlXq0wD/Va1eJZBV61auXb1+5RpA7FiyBMyeRZtW7Vq2aQO8hRuXwFy6de3exZvXbgC+ff0SABxY8GDChQ0PDpBY8WICjR0/hhxZ8mTIASxfxkxA82bOnT1/Bt05wGjSpQmcRp1a9WrWrVUHgB1bNgHatW3fxp1b9+0AvX3/JhBc+HDixY0fJx5A+XLmBJw/hx5dOgDq1a1fvx5A+3buALx/Bx8+PAEA5c2fR48+wHr27QG8hx9fvnwCAOzfx58/fwD+/f0DBCBwIMGCBQkASKhwIUOGAQIMEDBAwAABAQIAyKhxI0eOBACADCly5MgAAgYIGCBggIABAQDAjClz5kwCAG7i/8ypU+cAAQMEDBAwQMAAAQCOIk2qVCkBAE6fQo0aVcAAAQMEDBAwQMAAAF6/gg0blgCAsmbPokU7QMAAAQMEDBAwQACAunbv4sVLAADfvn7//hUwQMAAAQMEDBAwAADjxo4fPyYAYDLlypYtDxAwQMAAAQMEDBAAYDTp0qZNEwCgejXr1q0DDBAwQMAAAQMEBACgezfv3r0JAAgufDhx4gECCBggYICAAQECAIgufTp16gQAYM+ufTt37QG+fwcgfjz58uUJAEivfj379u7fw2dPAAD9+vbv48+vf/99AgAAAhA4kGBBgwcRJlS4kGHDhAQARJQ4kWJFixcxUiQAgJVjR48fQYYUOfIjAQAnUaZUuZJlS5cqCQCQOZNmTZs3ceasSQBAT58/gQYVOpQoUAIAkCZVupRpU6dPlxIAMJVqVatXsWbVapUAAK9fwYYVO5Zs2bAEAKRVu5ZtW7dv4bIlAIBuXbt38ebVu/cuAQB/AQcWPJhwYcOCCQBQvJhxY8ePIUduTABAZcuXMWfWvJkzZgIBAQAh/wtORVRTQ0FQRTIuMAMBAAAALCMBrAALAH0AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAMIFEigoMEACBMqJBCgocOHBAJInEiRQICLGDMSCMCxo0cCAUKKHEkggMmTKAkEWMmyJYEAMGPKJBCgps2bBALo3MmTQICfQIMSCEC0qFECAZIqXUoggNOnUAkEmEq1KoEAWLNqJRCgq9evBAKIHUuWQICzaNMSCMC2rVsCAeLKnUsggN27eAkE2Mu3L4EAgAMLJhCgsOHDBAIoXsyYQIDHkCMTCEC5smUCATJr3kwggOfPoAkEGE26NIEAqFOrJhCgtevXBALInk2bQIDbuHMTCMC7t28CAYILH04ggPHjyAkEWM68OYEA0KNLJxCguvXrBAJo386dQIDv4MMT/whAvrx5AgHSq19PIID79/AJBJhPvz6BAPjz6ycQoL9/gAEEBiAQwOBBhAQCLGTYkEAAiBElEghQ0eJFAgE0buRIIMBHkCEJBCBZ0iSBAClVriQQwOVLmAQCzKRZk0AAnDl1EgjQ0+dPAgGEDiVKIMBRpEkJBGDa1CmBAFGlTiUQwOpVrAQCbOXalUAAsGHFEghQ1uxZAgHUrmVLIMBbuHEJBKBb1y6BAHn17iUQwO9fwAQCDCZcmEAAxIkVEwjQ2PFjAgEkT6ZMIMBlzJkJBODc2TOBAKFFjyYQwPRp1AQCrGbdmkAA2LFlEwhQ2/ZtAgF07+ZNIMBv4MEJBCBe3P84gQDJlS8nEMD5c+gEAkynXp1AAOzZtRMI0N37dwIBxI8nTyDAefTpCQRg3949gQDx5c8nEMD+ffwEAuzn358AwAACBxIkEOAgwoQEAjBs6JBAgIgSJxIIYPEiRgIBNnLsSCAAyJAiCQQoafIkgQAqV7IkEOAlzJgEAtCsaZNAgJw6dxII4PMnUAABhhItCiAA0qRKAQQIMEDAAAEDBAQIACCAgAECBggYIGBAAAABBggYIGCAgAECBgAQMEDAAAEDBAwQMADAAAEDBAwQMEDAAAEABAwQMEDAAAEDBAwAEGCAgAECBggYIGAAgAACBggYIGCAgAEBAAQIMEDAAAEHAwQECAAgIAAh/wtORVRTQ0FQRTIuMAMBAAAALCMBrAAKAH4AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAiiAAkIFBigoMGDCBMqXMiwocOHECNKnEixosWLGDNq3Mixo8ePIEOKHEmypMmTKFOqXMmypcuXMGPKBDlAwAABAwQE2ClggIABAgYIGBAgwAABAwQMEDBAwIAAAgYIGCBggIABAgYIGCBggIABAgYICDBAwAABAwQMEDAggIABAgYIGCBggIAAAwQMEDBAwAABAQIPEDBAwAABARIrDgCgceOAACH/C05FVFNDQVBFMi4wAwEAAAAsIwGsAAoAfgCCAAAAzJlmZmbMmZnM////AAAAAAAAAAAACKcAAwgUSKBgwQAIEypcyLChw4cQI0qcSLGixYsYM2rcyLGjx48gQ4ocSbKkyZMoU6pcybKly5cwY8qcSbOmxwECBggYICCATwEDBAwQMEDAgAADBAwQMEDAAAEDAggYIGCAgAECBggYMEDAAAEDBAwQMECAgAECBggYIGCAgAEDBAwQMEDAAAEDAgQYIGCAgAECBggIQFjAAAEDBAwIEACAY8cBIkcOCAAh/wtORVRTQ0FQRTIuMAMBAAAALCMBrAAKAH4AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAihAAkIHEgwgMGDCBMqXMiwocOHECNKnEixosWLGDNq3Mixo8ePIEOKHEmypMmTKFOqXMmypcuXMGPKnMlxgIABAgYICMBTwAABAwQMEDAgwAABAwQMEDBAwAABAgYIGCBggIABAgYMEDBAwAABAwQMECBggIABAgYIGCBgwAABAwQMEDBAwAABAQYIGCBggIABAgIIFjBAwAABAwIoXsxYcUAAIf8LTkVUU0NBUEUyLjADAQAAACwOAawAMwCPAIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAI/wAJCBxIsKDBAAgREljIsKHDhxAjSiQQoKLFiwQyatzIsaPHjxwDiBxJkoDJkyhTqlzJMmWAlzBjEphJs6bNmzhz2gzAs6dPAkCDCh1KtKjRoQGSKl1KoKnTp1CjSp0KNYDVq1gJaN3KtavXr2C7BhhLtiyBs2jTql3Ltq3aAHDjyiVAt67du3jz6r0boK/fvwQCCx5MuLDhw4QDKF7MmIDjx5AjS55MOXKAy5gzE9jMubPnz6BDew5AurRpAqhTq17NurXr1QFiy55NoLbt27hz696NO4Dv38AJCB9OvLjx48iLB1jOvDmB59CjS59Ovbr0ANizayfAvbv37+DDi///HqC8+fME0qtfz769+/fsA8ifT5+A/fv48+vfzz9/AIABBA4cSMDgQYQJFS5kmDDAQ4gRCUykWNHiRYwZLQbg2NEjAZAhRY4kWdLkyAApVa4k0NLlS5gxZc6EGcDmTZwEdO7k2dPnT6A9AwwlWpTAUaRJlS5l2lRpAKhRpRKgWtXqVaxZtV4N0NXrVwJhxY4lW9bsWbIB1K5lS8DtW7hx5c6lGzfAXbx5Cezl29fvX8CB/QYgXNgwAcSJFS9m3Njx4gCRJU8mUNnyZcyZNW/GHMDzZ9AERI8mXdr0adSlA6xm3ZrAa9ixZc+mXVt2ANy5dRPg3dv3b+DBhf8OUNz/+HECyZUvZ97c+XPmAaRPp07A+nXs2bVv5549wHfw4QmMJ1/e/Hn06c0HYN/ePQH48eXPp1/f/vwA+fXvJ9DfP0ACAgcSLGjw4MEAChcyJODwIcSIEidSjBjgIsaMBDZy7OjxI8iQHgOQLGmSAMqUKleybOlyZYCYMmcSqGnzJs6cOnfiDODzJ1ACQocSLWr0KNKiAZYybUrgKdSoUqdSrSo1ANasWglw7er1K9iwYr8GKGv2LIG0ateybev2LdsAcufSJWD3Lt68evfyzRvgL+DABAYTLmz4MOLEhgMwbuyYAOTIkidTrmx5coDMmjcT6Oz5M+jQokeDDmD6NGoC/6pXs27t+jXs1gFm065N4Dbu3Lp38+6tOwDw4MIJEC9u/Djy5MqPB2ju/DmB6NKnU69u/Tr1ANq3cyfg/Tv48OLHkw8f4Dz69ATWs2/v/j38+O4D0K9vnwD+/Pr38+/vHyABgQIDFDR4kEBChQsZNnT4kGEAiRMpErB4EWNGjRs5ZgzwEWRIAiNJljR5EmVKkwFYtnRJAGZMmTNp1rQ5M0BOnTsJ9PT5E2hQoUOBBjB6FCkBpUuZNnX6FGrTAFOpViVwFWtWrVu5dtUaAGxYsQTIljV7Fm1atWcDtHX7lkBcuXPp1rV7l24AvXv5EvD7F3BgwYMJBw5wGHFiAosZN/92/BhyZMcBKFe2TABzZs2bOXf2vDlAaNGjCZQ2fRp1atWrUQdw/Ro2Admzade2fRt37QC7efcm8Bt4cOHDiRcXHgB5cuUEmDd3/hx6dOnPA1S3fp1Adu3buXf3/p17APHjyRMwfx59evXr2acP8B5+fALz6de3fx9/fvsB+Pf3D5CAwIEECxo8iLBggIUMGxJ4CDGixIkUK0oMgDGjRgIcO3r8CDKkSI8BSpo8SSClypUsW7p8yTKAzJk0Cdi8iTOnzp08cwb4CTQogaFEixo9ijSp0QBMmzolADWq1KlUq1qdGiCr1q0Eunr9Cjas2LFgA5g9i5aA2rVs27p9C7f/bYC5dOsSuIs3r969fPvqDQA4sGAChAsbPow4seLDARo7fkwgsuTJlCtbvkw5gObNnAl4/gw6tOjRpEMHOI06NYHVrFu7fg07tusAtGvbJoA7t+7dvHv73h0guPDhBIobP448ufLlyAM4fw6dgPTp1Ktbv469eoDt3LsT+A4+vPjx5MuLD4A+vXoC7Nu7fw8/vvz3Aerbv08gv/79/Pv7B0hA4ECCAwMcRJiQwEKGDR0+hBjRYQCKFS0SwJhR40aOHT1uDBBS5EgCJU2eRJlS5UqUAVy+hElA5kyaNW3exFkzwE6ePQn8BBpU6FCiRYUGQJpUKQGmTZ0+hRpV6tMA/1WtXiWQVetWrl29fuUaQOxYsgTMnkWbVu1atmkDvIUbl8BcunXt3sWb124Avn39EgAcWPBgwoUNDw6QWPFiAo0dP4YcWfJkyAEsX8ZMQPNmzp09fwbdOcBo0qUJnEadWvVq1q1VB4AdWzYB2rVt38adW/ftAL19/yYQXPhw4sWNHyceQPly5gScP4ceXToA6tWtX78eQPt27gC8fwcfPjwBAOXNn0ePPsB69u0BvIcfX758AgDs38efP38A/v39AwQgcCDBggUJAEiocCFDhgECDBAwQMAAAQECAMiocSNHjgQAgAwpcuTIAAIGCBggYICAAQEAwIwpc+ZMAgBu4v/MqVNngAECBggYIGCAgAEAjiJNqlQpAQBOn0KNGlXAAAEDBAwQMEDAAABev4ING5YAgLJmz6JFO0DAAAEDBAwQMEAAgLp27+LFSwAA375+//4VMEDAAAEDBAwQMAAA48aOHz8mAGAy5cqWLQcYIGCAgAECBggYAGA06dKmTRMAoHo169atAwgYIGCAgAECBgQAoHs37969CQAILnw4ceIBAgwQMEDAAAEBAgCILn06deoEAGDPrn07d+0Bvn8HIH48+fLlCQBIr349+/bu38NnTwAA/fr27+PPr3//fQIAAAIQOJBgQYMHESZUuJBhw4QEAESUOJFiRYsXMVIkAICVY0ePH0GGFDnyIwEAJ1GmVLmSZUuXKgkAkDmTZk2bN3HmrEkAQE+fP4EGFTqUKFACAJAmVbqUaVOnT5cSADCValWrV7Fm1WqVAACvX8GGFTuWbNmwBACkVbuWbVu3b+GyJQCAbl27d/Hm1bv3LgEAfwEHFjyYcGHDggkAULyYcWPHjyFHbkwAQGXLlzFn1ryZM2YCAQEAIf8LTkVUU0NBUEUyLjADAQAAACwiAawACwB8AIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAI/wAJBBgYgIDBgwQCKFzIkECAhxAjEghAsaJFAgEyatxIIIDHjyAJBBhJsiSBAChTqiQQoKXLlwQCyJxJk0CAmzhzEgjAs6dPAgGCCh1KIIDRo0gJBFjKtCmBAFCjSiUQoKrVqwQCaN3KlUCAr2DDEghAtqxZAgHSql1LIIDbt3AJBJhLty6BAHjz6iUQoK/fvwQCCB5MmECAw4gTEwjAuLFjAgEiS55MIIDly5gJBNjMuTOBAKBDiyYQoLTp0wQCqF7NmkCA17BjEwhAu7ZtAgFy695NIIDv38AJBBhOvDiBAMiTKycQoLnz5wQCSJ9OnUCA69izEwjAvbt3AgHCi/8fTyCA+fPoCQRYz749gQDw48snEKC+/fsEAujfz59AAIABBA4cSCDAQYQJCQRg2NAhgQARJU4kEMDiRYwEAmzk2JFAAJAhRRIIUNLkSQIBVK5kSSDAS5gxCQSgWdMmgQA5de4kEMDnT6AEAgwlWpRAAKRJlRII0NTpUwIBpE6lSiDAVaxZCQTg2tUrgQBhxY4lEMDsWbQEAqxl25ZAALhx5RIIUNfuXQIB9O7lSyDAX8CBCQQgXNgwgQCJFS8mEMDxY8gEAkymXJlAAMyZNRMI0NnzZwIBRI8mTSDAadSpCQRg3do1gQCxZc8mEMD2bdwEAuzm3ZtAAODBhRMIUNz4+HECAZQvZ04gwHPo0QkEoF7dOoEA2bVvJxDA+3fwBAKMJ1+eQAD06dUTCNDe/XsCAeTPp08gwH38+QkE4N/fP0ACAQYSLEggAMKECgkEaOjwIYEAEidSJBDgIsaMBAJw7Ojx40cCAUaSLEkgAMqUKgkEaOnyJYEAMmfSJBDgJs6cBALw7OkTQICgQocCCGD0KFIAAQIMEDBAwAABAQIACCBggIABAgYIGBAAQIABAgYIGCBggIABAAIIGCBggIABAgYIADBAwAABAwQMEDBAAIAAAwQMEDBAwAABAwAEEDBAwAABAwQMEAAgwAABAwQMEDBAQAAAAQEAIf8LTkVUU0NBUEUyLjADAQAAACwOAawAMwCPAIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAI/wAJCBxIsKDBgwgTKlxoMIDDhxAJSJxIsaLFixgrBtjIsSOBjyBDihxJsqTIAChTqiTAsqXLlzBjynwZoKbNmwRy6tzJs6fPnzwDCB1KlIDRo0iTKl3KNGmAp1CjEphKtarVq1izWg3AtatXAmDDih1LtqzZsQHSql1LoK3bt3Djyp0LN4Ddu3gJ6N3Lt6/fv4D7BhhMuDCBw4gTK17MuLHiAJAjSyZAubLly5gza74coLPnzwRCix5NurTp06QDqF7NmoDr17Bjy55NO3aA27hzE9jNu7fv38CD+w5AvLhxAsiTK1/OvLnz5QGiS59OoLr169iza9+OPYD37+AJiP8fT768+fPoywdYz749gffw48ufT7++/AD48+snwL+/f4AEBA4kWNDgwYEBFC5kSMDhQ4gRJU6kGDHARYwZCWzk2NHjR5AhPQYgWdIkAZQpVa5k2dLlygAxZc4kUNPmTZw5de7EGcDnT6AEhA4lWtToUaRFAyxl2pTAU6hRpU6lWlVqAKxZtRLg2tXrV7BhxX4NUNbsWQJp1a5l29btW7YB5M6lS8DuXbx59e7lmzfAX8CBCQwmXNjwYcSJDQdg3NgxAciRJU+mXNny5ACZNW8m0NnzZ9ChRY8GHcD0adQEVK9m3dr1a9itA8ymXZvAbdy5de/m3Vt3AODBhRMgXtz/+HHkyZUfD9Dc+XMC0aVPp17d+nXqAbRv507A+3fw4cWPJx8+wHn06QmsZ9/e/Xv48d0HoF/fPgH8+fXv59/fP0ACAgUGKGjwIIGEChcybOjwIcMAEidSJGDxIsaMGjdyzBjgI8iQBEaSLGnyJMqUJgOwbOmSAMyYMmfSrGlzZoCcOncS6OnzJ9CgQocCDWD0KFICSpcyber0KdSmAaZSrUrgKtasWrdy7ao1ANiwYgmQLWv2LNq0as8GaOv2LYG4cufSrWv3Lt0AevfyJeD3L+DAggcTDhzgMOLEBBYzbuz4MeTIjgNQrmyZAObMmjdz7ux5c4DQokcTKG36NOrU/6pXow7g+jVsArJn065t+zbu2gF28+5N4Dfw4MKHEy8uPADy5MoJMG/u/Dn06NKfB6hu/TqB7Nq3c+/u/Tv3AOLHkydg/jz69OrXs08f4D38+ATm069v/z7+/PYD8O/vHyABgQMJFjR4EGHBAAsZNiTwEGJEiRMpVpQYAGNGjQQ4dvT4EWRIkR8DlDR5kkBKlStZtnT5kmUAmTNpErB5E2dOnTt55gzwE2hQAkOJFjV6FGlSowGYNnVKAGpUqVOpVrU6NUBWrVsJdPX6FWxYsWPBBjB7Fi0BtWvZtnX7Fm7bAHPp1iVwF29evXv59tUbAHBgwQQIFzZ8GHFixYcDNP92/JhAZMmTKVe2fJlyAM2bORPw/Bl0aNGjSYcOcBp1agKrWbd2/Rp2bNcBaNe2TQB3bt27eff2vTtAcOHDCRQ3fhx5cuXLkQdw/hw6AenTqVe3fh179QDbuXcn8B18ePHjyZcXHwB9evUE2Ld3/x5+fPnvA9S3f59Afv37+ff3D5CAwIEEBwY4iDAhgYUMGzp8CDGiwwAUK1okgDGjxo0cO3rcGCCkyJEESpo8iTKlypUoA7h8CZOAzJk0a9q8ibNmgJ08exL4CTSo0KFEiwoNgDSpUgJMmzp9CjWq1KcBqlq9SiCr1q1cu3r9yjWA2LFkCZg9izat2rVs0wZ4Czf/LoG5dOvavYs3r90AfPv6JQA4sODBhAsbHhwgseLFBBo7fgw5suTJkANYvoyZgObNnDt7/gy6c4DRpEsTOI06terVrFurDgA7tmwCtGvbvo07t+7bAXr7/k0guPDhxIsbP048gPLlzAk4fw49uvTp1KMHuI49O4Ht3Lt7/w4+vPcA5MubJ4A+vfr17Nu7Xx8gvvz5BOrbv48/v/79+AP4BxhA4MAABAweRJhQ4UKGCQM8hBiRwESKFS1exJjRYgCOHT0SABlS5EiSJU2ODJBS5UoCLV2+hBlT5kyYAWzexElA506ePX3+BNozwFCiRQkcRZpU6VKmTZUGgBpVKgGq/1WtXsWaVevVAF29fiUQVuxYsmXNniUbQO1atgTcvoUbV+5cunED3MWbl8Bevn39/gUc2G8AwoUNE0CcWPFixo0dLw4QWfJkApUtX8acWfNmzAE8fwZNQPRo0qVNn0ZdOsBq1q0JvIYdW/Zs2rVlB8CdWzcB3r19/wYeXPjvAMWNHyeQXPly5s0BPIceXbr0ANWtXweQXft27twJAAAfXvz48QHMn0cPQP169u3bEwAQX/58+vQD3MefH8B+/v39AwQgUCABAAYPIkyYMECAAQIGCBggIEAAABYvYsyYkQCAjh4/ggQZQMAAAQMEDBAwIACAli5fwoRJAADNmjZv3v8cIGCAgAECBggYEAAA0aJGjx4lAGAp06ZOnQoYIGCAgAECBggYAGAr165evRIAIHYs2bJlBwgYIGCAgAECBggAIHcu3bp1CQDIq3cvX74CBggYIGCAgAECBgBIrHgxY8YEAECOLHny5AECBggYIGCAgAEBAIAOLXr0aAIATqNOrVp1gAECBggYIGCAgAAAbuPOrVs3AQC+fwMPHjxAAAEDBAwQMCBAAADOn0OPHp0AgOrWr2PHHmA79+4AvoMPL148AQDmz6NPr349+/bpCQCIL38+/fr27+PPr38///wEAAIQOJBgQYMHESYsSABAQ4cPIUaUOJEiRAIAMGbUuJGPY0ePHzcSADCSZEmTJ1GmVGmSAACXL2HGlDmTZs2YBADk1LmTZ0+fP4HyJACAaFGjR5EmVbr0KAEAT6FGlTqValWrUgkA0LqVa1evX8GG7UoAQFmzZ9GmVbuWLVoCAODGlTuXbl27d+cSALCXb1+/fwEHFuyXAADDhxEnVryYcePEBABEljyZcmXLlzFTDggAIf8LTkVUU0NBUEUyLjADAQAAACwiAawACwB+AIIAAADMmWZmZsyZmcz///8AAAAAAAAAAAAI/wAJCBQYoGBBAgESKlxIIIDDhxAJBJhIsSKBABgzaiQQoKPHjwQCiBxJkkCAkyhTEgjAsqVLAgFiypxJIIDNmzgJEAjAs6dPAgGCCh1KIIDRo0gJBFjKtCmBAFCjSiUQoKrVqwQCaN3KlUCAr2DDEghAtqxZAgHSql1LIIDbt3AJBJhLty6BAHjz6iUQoK/fvwQCCB5MmECAw4gTEwjAuLFjAgEiS55MIIDly5gJBNjMuTOBAKBDiyYQoLTp0wQCqF7NmkCA17BjEwhAu7ZtAgFy695NIIDv38AJBBhOvDiBAMiTKycQoLnz5wQCSJ9OnUCA69izEwjAvbt3AgHCi/8fTyCA+fPoCQRYz749gQDw48snEKC+/fsEAujfz59AAIABBA4cSCDAQYQJCQRg2NAhgQARJU4kEMDiRYwEAmzk2JFAAJAhRRIIUNLkSQIBVK5kSSDAS5gxCQSgWdMmgQA5de4kEMDnT6AEAgwlWpRAAKRJlRII0NTpUwIBpE6lSiDAVaxZCQTg2tUrgQBhxY4lEMDsWbQEAqxl25ZAALhx5RIIUNfuXQIB9O7lSyDAX8CBCQQgXNgwgQCJFS8mEMDxY8gEAkymXJlAAMyZNRMI0NnzZwIBRI8mTSDAadSpCQRg3do1gQCxZc8mEMD2bdwEAuzm3ZtAAODBhRMIUNz/+HECAZQvZ04gwHPo0QkEoF7dOoEA2bVvJxDA+3fwBAKMJ1+eQAD06dUTCNDe/XsCAeTPp08gwH38+QkE4N/fP0ACAQYSLEggAMKECgkEaOjwIYEAEidSJBDgIsaMBAJw7OiRQICQIkcSCGDyJEoCAVaybEkgAMyYMgkEqGnzJoEAOnfyBBDgJ9CgAAIQLWoUQICkSpcCCBBggIABAgYICBAAQAABAwQMEDBAwIAAAAYIGCBggIABAgYIACBggIABAgYIGCBgAIABAgYIGCBggIABAgAIGCBggIABAgYIGABggIABAgYIGCBggAAAAQYIGCBggIABAgIACBBAwAABDwMEDAgQAECA2LEB0KYdEAAh/wtORVRTQ0FQRTIuMAMBAAAALA4BrAAzAI8AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIHEiwoMEACBESWMiwocOHECNKJBCgosWLBDJq3Mixo8ePHAOIHEmSgMmTKFOqXMkyZYCXMGMSmEmzps2bOHPaDMCzp08CQIMKHUq0qNGhAZIqXUqgqdOnUKNKnQo1gNWrWAlo3cq1q9evYLsGGEu2LIGzaNOqXcu2rdoAcOPKJUC3rt27ePPqvRugr9+/BAILHky4sOHDhAMoXsyYgOPHkCNLnkw5coDLmDMT2My5s+fPoEN7DkC6tGkCqFOrXs26tevVAWLLnk2gtu3buHPr3o07gO/fwAkIH068uPHjyIsHWM68OYHn0KNLn069uvQA2LNrJ8C9u/fv4MOL//8eoLz58wTSq1/Pvr379+wDyJ9Pn4D9+/jz69/PP38AgAEEDhxIwOBBhAkVLmSYMMBDiBEJTKRY0eJFjBktBuDY0SMBkCFFjiRZ0uTIAClVriTQ0uVLmDFlzoQZwOZNnAR07uTZ0+dPoD0DDCValMBRpEmVLmXaVGkAqFGlEqBa1epVrFm1Xg3Q1etXAmHFjiVb1uxZsgHUrmVLwO1buHHlzqUbN8BdvHkJ7OXb1+9fwIH9BiBc2DABxIkVL2bc2PHiAJElTyZQ2fJlzJk1b8YcwPNn0AREjyZd2vRp1KUDrGbdmsBr2LFlz6ZdW3YA3Ll1E+Dd2/dv4MGF/w5Q3P/4cQLJlS9n3tz5c+YBpE+nTsD6dezZtW/nnj3Ad/DhCYwnX978efTpzQdg3949Afjx5c+nX9/+/AD59e8n0N8/QAICBxIsaPDgwQAKFzIk4PAhxIgSJ1KMGOAixowENnLs6PEjyJAeA5AsaZIAypQqV7Js6VJlgJgyZxKoafMmzpw6d+IM4PMnUAJChxItavQo0qIBljJtSuAp1KhSp1KtKjUA1qxaCXDt6vUr2LBivwYoa/YsgbRq17Jt6/Yt2wBy59IlYPcu3rx69/LNG+Av4MAEBhMubPgw4sSGAzBu7JgA5MiSJ1OubHlygMyaNxPo7Pkz6NCiR4MOYPo0agL/qlezbu36NezWAWbTrk3gNu7cunfz7q07APDgwgkQL278OPLkyo8HaO78OYHo0qdTr279OvUA2rdzJ+D9O/jw4seTDx/gPPr0BNazb+/+Pfz47gPQr2+fAP78+vfz7+8fIAGBAgMUNHiQQEKFCxk2dPiQYQCJEykSsHgRY0aNGzlmDPARZEgCI0mWNHkSZUqTAVi2dEkAZkyZM2nWtDkzQE6dOwn09PkTaFChQ4EGMHoUKQGlS5k2dfoUatMAU6lWJXAVa1atW7l21RoAbFixBMiWNXsWbVq1ZwO0dfuWQFy5c+nWtXuXbgC9e/kS8PsXcGDBgwkHDnAYcWICixk3/3b8GHJkxwEoV7ZMAHNmzZs5d/a8OUBo0aMJlDZ9GnVq1atRB3D9GjYB2bNp17Z9G3ftALt59ybwG3hw4cOJFxceAHly5QSYN3f+HHp06c8DVLd+nUB27du5d/f+nXsA8ePJEzB/Hn169evZpw/wHn58AvPp17d/H39++wH49/cPkIDAgQQLGjyIsGCAhQwbEngIMaLEiRQrSgyAMaNGAhw7evwIMqTIjwFKmjxJIKXKlSxbunzJMoDMmTQJ2LyJM6fOnTxzBvgJNCiBoUSLGj2KNKnRAEybOiUANarUqVSrWp0aIKvWrQS6ev0KNqzYsWADmD2LloDatWzbun0Lt/9tgLl06xK4izev3r18++oNADiwYAKECxs+jDix4sMBGjt+TCCy5MmUK1u+TDmA5s2cCXj+DDq06NGkQwc4jTo1gdWsW7t+DTu26wC0a9smgDu37t28e/veHSC48OEEihs/jjy58uXIAzh/Dp2A9OnUq1u/jr16gO3cuxP4Dj68+PHky4sPgD69egLs27t/Dz++/PcB6tu/TyC//v38+/sHSEDgQIIDAxxEmJDAQoYNHT6EGNFhAIoVLRLAmFHjRo4dPW4MEFLkSAIlTZ5EmVLlSpQBXL6ESUDmTJo1bd7EWTPATp49CfwEGlToUKJFhQZAmlQpAaZNnT6FGlXq0wD/Va1eJZBV61auXb1+5RpA7FiyBMyeRZtW7Vq2aQO8hRuXwFy6de3exZvXbgC+ff0SABxY8GDChQ0PDpBY8WICjR0/hhxZ8mTIASxfxkxA82bOnT1/Bt05wGjSpQmcRp1a9WrWrVUHgB1bNgHatW3fxp1b9+0AvX3/JhBc+HDixY0fJx5A+XLmBJw/hx5dOgDq1a1fvx5A+3buALx/Bx8+PAEA5c2fR48+wHr27QG8hx9fvnwCAOzfx58/fwD+/f0DBCBwIMGCBQkASKhwIUOGAQIMEDBAwAABAQIAyKhxI0eOBACADCly5MgAAgYIGCBggIABAQDAjClz5kwCAG7i/8ypU2eAAQIGCBggYICAAQCOIk2qVCkBAE6fQo0aVcAAAQMEDBAwQMAAAF6/gg0blgCAsmbPokU7QMAAAQMEDBAwQACAunbv4sVLAADfvn7//hUwQMAAAQMEDBAwAADjxo4fPyYAYDLlypYtBxggYICAAQIGCBgAYDTp0qZNEwCgejXr1q0DCBggYICAAQIGBACgezfv3r0JAAgufDhx4gECDBAwQMAAAQECAIgufTp16gQAYM+ufTt37QG+fwcgfjz58uUJAEivfj379u7fw2dPAAD9+vbv48+vf/99AgAAAhA4kGBBgwcRJlS4kGHDhAQARJQ4kWJFixcxUiQAgJVjR48fQYYUOfIjAQAnUaZUuZJlS5cqCQCQOZNmTZs3ceasSQBAT58/gQYVOpQoUAIAkCZVupRpU6dPlxIAMJVqVatXsWbVapUAAK9fwYYVO5Zs2bAEAKRVu5ZtW7dv4bIlAIBuXbt38ebVu/cuAQB/AQcWPJhwYcOCCQBQvJhxY8ePIUduTABAZcuXMWfWvJkzZgIBAQAh/wtORVRTQ0FQRTIuMAMBAAAALCIBrAALAH4AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIFBigYEECARIqXEgggMOHEAkEmEixIoEAGDNqJBCgo8ePBAKIHEmSQICTKFMSCMCypUsCAWLKnEkggM2bOAkE2MmzJ4EAQIMKJRCgqNGjBAIoXcqUQICnUKMSCEC1qlUCAbJq3UoggNevYAkEGEu2LIEAaNOqJRCgrdu3BALInUuXQIC7ePMSCMC3r18CAQILHkwggOHDiAkEWMy4MYEAkCNLJhCgsuXLBAJo3syZQIDPoEMTCEC6tGkCAVKrXk0ggOvXsAkEmE27NoEAuHPrJhCgt+/fBAIIH06cQIDjyJMTCMC8uXMCAaJLn04ggPXr2AkE2M69O4EA4MOL/ycQoLz58wQCqF/PnkCA9/DjEwhAv759AgHy699PIIB/gAEEDgxAIMBBhAkJBGDY0CGBABElTiQQwOJFjAQCbOTYkUAAkCFFEghQ0uRJAgFUrmRJIMBLmDEJBKBZ0yaBADl17iQQwOdPoAQCDCValEAApEmVEgjQ1OlTAgGkTqVKIMBVrFkJBODa1SuBAGHFjiUQwOxZtAQCrGXblkAAuHHlEghQ1+5dAgH07uVLIMBfwIEJBCBc2DCBAIkVLyYQwPFjyAQCTKZcmUAAzJk1EwjQ2fNnAgFEjyZNIMBp1KkJBGDd2jWBALFlzyYQwPZt3AQC7Obdm0AA4MGFEwhQ3P/4cQIBlC9nTiDAc+jRCQSgXt06gQDZtW8nEMD7d/AEAownX55AAPTp1RMI0N79ewIB5M+nTyDAffz5CQTg398/QAIBBhIsSCAAwoQKCQRo6PAhgQASJ1IkEOAixowEAnDs6JFAgJAiRxIIYPIkSgIBVrJsSSAAzJgyCQSoafMmgQA6d/IkEOAn0KAAAhAtahRAgKRKlwIIEGCAgAECBggIEABAAAEDBAwQMEDAgAAAAgwQMEDAAAEDBAwAEEDAAAEDBAwQMEAAgAECBggYIGCAgAECAAQYIGCAgAECBggYACCAgAECBggYIGCAAAABBggYIGCAgAECAgAIEGCAgAEPAgYICBAAQIDYsQHQrh0QACH/C05FVFNDQVBFMi4wAwEAAAAsDgGsADMAjwCCAAAAzJlmZmbMmZnM////AAAAAAAAAAAACP8ACQgcSLCgwYIBEgYgwLChw4cQI0p8GKCixYsEMmrcyLGjx48cA4gcSZKAyZMoU6pcyTJlgJcwYxKYSbOmzZs4c9oMwLOnTwJAgwodSrSo0aEBkipdSqCp06dQo0qdCjWA1atYCWjdyrWr169guwYYS7YsgbNo06pdy7at2gBw48olQLeu3bt48+q9G6Cv378EAgseTLiw4cOEAyhezJiA48eQI0ueTDlygMuYMxPYzLmz58+gQ3sOQLq0aQKoU6tezbq169UBYsueTaC27du4c+vejTuA79/ACQgfTry48ePIiwdYzrw5gefQo0ufTr269ADYs2snwL279+/gw4v//x6gvPnzBNKrX8++vfv37APIn0+fgP37+PPr388/fwCAAQQOHEjA4EGECRUuZJgwwEOIEQlMpFjR4kWMGS0G4NjRIwGQIUWOJFnS5MgAKVWuJNDS5UuYMWXOhBnA5k2cBHTu5NnT50+gPQMMJVqUwFGkSZUuZdpUaQCoUaUSoFrV6lWsWbVeDdDV61cCYcWOJVvW7FmyAdSuZUvA7Vu4ceXOpRs3wF28eQns5dvX71/Agf0GIFzYMAHEiRUvZtzY8eIAkSVPJlDZ8mXMmTVvxhzA82fQBESPJl3a9GnUpQOsZt2awGvYsWXPpl1bdgDcuXUT4N3b92/gwYX/DlDc//hxAsmVL2fe3Plz5gGkT6dOwPp17Nm1b+eePcB38OEJjCdf3vx59OnNB2Df3j0B+PHlz6df3/78APn17yfQ3z9AAgIHEixo8ODBAAoXMiTg8CHEiBInUowY4CLGjAQ2cuzo8SPIkB4DkCxpkgDKlCpXsmzpcmWAmDJnEqhp8ybOnDp34gzg8ydQAkKHEi1q9CjSogGWMm1K4CnUqFKnUq0qNQDWrFoJcO3q9SvYsGK/Bihr9iyBtGrXsm3r9i3bAHLn0iVg9y7evHr38s0b4C/gwAQGEy5s+DDixIYDMG7smADkyJInU65seXKAzJo3E+js+TPo0KJHgw5g+jRqAv+qV7Nu7fo17NYBZtOuTeA27ty6d/PurTsA8ODCCRAvbvw48uTKjwdo7vw5gejSp1Ovbv069QDat3Mn4P07+PDix5MPH+A8+vQE1rNv7/49/PjuA9Cvb58A/vz69/Pv7x8gAYECAxQ0eJBAQoULGTZ0+JBhAIkTKRKweBFjRo0bOWYM8BFkSAIjSZY0eRJlSpMBWLZ0SQBmTJkzada0OTNATp07CfT0+RNoUKFDgQYwehQpAaVLmTZ1+hRq0wBTqVYlcBVrVq1buXbVGgBsWLEEyJY1exZtWrVnA7R1+5ZAXLlz6da1e5duAL17+RLw+xdwYMGDCQcOcBhxYgKLGTf/dvwYcmTHAShXtkwAc2bNmzl39rw5QGjRowmUNn0adWrVq1EHcP0aNgHZs2nXtn0bd+0Au3n3JvAbeHDhw4kXFx4AeXLlBJg3d/4cenTpzwNUt36dQHbt27l39/6dewDx48kHIHAefXr169m3Vx8Afnz5BOjXt38ff3799wP09w8wgMAABAoaPIgwocKFCAM4fAiRgMSJFCtavIixYoCNHDsS+AgypMiRJEuKDIAypUoCLFu6fAkzpsyXAWravEkgp86dPHv6/MkzgNChRAkYPYo0qdKlTJMGeAo1KoGpVKtavYo1q9UAXLt6JQA2rNixZMuaHRsgrdq1BNq6fQs3/67cuXAD2L2Ll4DevXz7+v0LuG+AwYQLEziMOLHixYwbKw4AObJkApQrW76MObPmywE6e/5MILTo0aRLmz5NOoDq1awJuH4NO7bs2bRjB7iNOzeB3bx7+/4NPLjvAMSLGyeAPLny5cybO18eILr06QSqW7+OPbv27dgDeP8OnoD48eTLmz+PvnyA9ezbE3gPP778+fTryw+AP79+Avz7+wdIQOBAggUNHhwYQOFChgQcPoQYUeJEihEDXMSYkcBGjh09fgQZ0mMAkiVNEkCZUuVKli1drgwQU+ZMAjVt3sSZU+dOnAF8/gRKQOhQokWNHkVaNMBSpk0JPIUaVepUqv9VpQbAmlUrAa5dvX4FG1bs1wBlzZ4lkFbtWrZt3b5lG0DuXLoE7N7Fm1fvXr55A/wFHJjAYMKFDR9GnNhwAMaNHROAHFnyZMqVLU8OkFnzZgKdPX8GHVr0aNABTJ9GTUD1atatXb+G3TrAbNq1CdzGnVv3bt69dQcAHlw4AeLFjR9Hnlz58QDNnT8nEF36dOrVAVzHnl279gDdvX8HEF78ePLkCQBAn179+vUB3L+HD0D+fPr16xMAkF//fv78AwAMIHDgQAAGDyJMmJAAgIYOH0KEGCDAAAEDBAwQECAAgI4eP4IESQAAyZImT54MIGCAgAECBggYEAAAzZo2b97/JABgJ8+ePn0OEDBAwAABAwQMCABgKdOmTp0SACB1KtWqVQUMEDBAwAABAwQMACB2LNmyZQkASKt2LVu2AwQMEDBAwAABAwQAyKt3L1++BAAADix48GABAwQMEDBAwAABAwBAjix58mQCAC5jzqxZ8wABAwQMEDBAwIAAAE6jTq1aNQEArl/Djh07wAABAwQMEDBAQAAAvn8DDx6cAIDixo8jRx4ggIABAgYIGBAgAIDq1q9jx04AAPfu3r9/DyBePIDy5s+jT3+eAID27t/Djy9/Pn34BADgz69/P//+/gECEDiQYEGDBxEmVKiQAACHDyFGlDiRYsWIBABk1LiRnGNHjx9BciQAgGRJkydRplS58iQBAC9hxpQ5k2ZNmzIJANC5k2dPnz+BBu1JAEBRo0eRJlW6lClSAgCgRpU6lWpVq1enEgCwlWtXr1/BhhXrlQAAs2fRplW7lm3btAQAxJU7l25du3fx0iUAgG9fv38BBxY8+C8BAIcRJ1a8mHFjx4oJAJA8mXJly5cxZ65MAEBnz59BhxY9mjTogAAh/wtORVRTQ0FQRTIuMAMBAAAALA4BrAAzAI8AggAAAMyZZmZmzJmZzP///wAAAAAAAAAAAAj/AAkIHEiwYMEACBESWMiwocOHECNKJBCgosWLBDJq3Mixo8ePHAOIHEmSgMmTKFOqXMkyZYCXMGMSmEmzps2bOHPaDMCzp08CQIMKHUq0qNGhAZIqXUqgqdOnUKNKnQo1gNWrWAlo3cq1q9evYLsGGEu2LIGzaNOqXcu2rdoAcOPKJUC3rt27ePPqvRugr9+/BAILHky4sOHDhAMoXsyYgOPHkCNLnkw5coDLmDMT2My5s+fPoEN7DkC6tGkCqFOrXs26tevVAWLLnk2gtu3buHPr3o07gO/fwAkIH068uPHjyIsHWM68OYHn0KNLn069uvQA2LNrJ8C9u/fv4MOL//8eoLz58wTSq1/Pvr379+wDyJ9Pn4D9+/jz69/PP38AgAEEDhxIwOBBhAkVLmSYMMBDiBEJTKRY0eJFjBktBuDY0SMBkCFFjiRZ0uTIAClVriTQ0uVLmDFlzoQZwOZNnAR07uTZ0+dPoD0DDCValMBRpEmVLmXaVGkAqFGlEqBa1epVrFm1Xg3Q1etXAmHFjiVb1uxZsgHUrmVLwO1buHHlzqUbN8BdvHkJ7OXb1+9fwIH9BiBc2DABxIkVL2bc2PHiAJElTyZQ2fJlzJk1b8YcwPNn0AREjyZd2vRp1KUDrGbdmsBr2LFlz6ZdW3YA3Ll1E+Dd2/dv4MGF/w5Q3P/4cQLJlS9n3tz5c+YBpE+nTsD6dezZtW/nnj3Ad/DhCYwnX978efTpzQdg3949Afjx5c+nX9/+/AD59e8n0N8/QAICBxIsaPDgwQAKFzIk4PAhxIgSJ1KMGOAixowENnLs6PEjyJAeA5AsaZIAypQqV7Js6XJlgJgyZxKoafMmzpw6d+IM4PMnUAJChxItavQo0qIBljJtSuAp1KhSp1KtKjUA1qxaCXDt6vUr2LBivwYoa/YsgbRq17Jt6/Yt2wBy59IlYPcu3rx69/LNG+Av4MAEBhMubPgw4sSGAzBu7JgA5MiSJ1OubHlygMyaNxPo7Pkz6NCiR4MOYPo0agL/qlezbu36NezWAWbTrk3gNu7cunfz7q07APDgwgkQL278OPLkyo8HaO78OYHo0qdTr279OvUA2rdzJ+D9O/jw4seTDx/gPPr0BNazb+/+Pfz47gPQr2+fAP78+vfz7+8fIAGBAgMUNHiQQEKFCxk2dPiQYQCJEykSsHgRY0aNGzlmDPARZEgCI0mWNHkSZUqTAVi2dEkAZkyZM2nWtDkzQE6dOwn09PkTaFChQ4EGMHoUKQGlS5k2dfoUatMAU6lWJXAVa1atW7l21RoAbFixBMiWNXsWbVq1ZwO0dfuWQFy5c+nWtXuXbgC9e/kS8PsXcGDBgwkHDnAYcWICixk3/3b8GHJkxwEoV7ZMAHNmzZs5d/a8OUBo0aMJlDZ9GnVq1atRB3D9GjYB2bNp17Z9G3ftALt59ybwG3hw4cOJFxceAHly5QSYN3f+HHp06c8DVLd+nUB27du5d/f+nXsA8ePJEzB/Hn169evZpw/wHn58AvPp17d/H39++wH49/cPkIDAgQQLGjyIsGCAhQwbEngIMaLEiRQrSgyAMaNGAhw7evwIMqTIjwFKmjxJIKXKlSxbunzJMoDMmTQJ2LyJM6fOnTxzBvgJNCiBoUSLGj2KNKnRAEybOiUANarUqVSrWp0aIKvWrQS6ev0KNqzYsWADmD2LloDatWzbun0Lt/9tgLl06xK4izev3r18++oNADiwYAKECxs+jDix4sMBGjt+TCCy5MmUK1u+TDmA5s2cCXj+DDq06NGkQwc4jTo1gdWsW7t+DTu26wC0a9smgDu37t28e/veHSC48OEEihs/jjy58uXIAzh/Dp2A9OnUq1u/jr16gO3cuxP4Dj68+PHky4sPgD69egLs27t/Dz++/PcB6tu/TyC//v38+/sHSEDgQIIDAxxEmJDAQoYNHT6EGNFhAIoVLRLAmFHjRo4dPW4MEFLkSAIlTZ5EmVLlSpQBXL6ESUDmTJo1bd7EWTPATp49CfwEGlToUKJFhQZAmlQpAaZNnT6FGlXq0wD/Va1eJZBV61auXb1+5RpA7FiyBMyeRZtW7Vq2aQO8hRuXwFy6de3exZvXbgC+ff0SABxY8GDChQ0PDpBY8WICjR0/hhxZ8mTIASxfxkxA82bOnT1/Bt05wGjSpQmcRp1a9WrWrVUHgB1bNgHatW3fxp1b9+0AvX3/JhBc+HDixY0fJx5A+XLmBJw/hx5dOgDq1a1fvx5A+3buALx/Bx8+PAEA5c2fR48+wHr27QG8hx9fvnwCAOzfx58/fwD+/f0DBCBwIMGCBQkASKhwIUOGAQIMEDBAwAABAQIAyKhxI0eOBACADCly5MgAAgYIGCBggIABAQDAjClz5kwCAG7i/8ypU+cAAQMEDBAwQMAAAQCOIk2qVCkBAE6fQo0aVcAAAQMEDBAwQMAAAF6/gg0blgCAsmbPokU7QMAAAQMEDBAwQACAunbv4sVLAADfvn7//hUwQMAAAQMEDBAwAADjxo4fPyYAYDLlypYtDxAwQMAAAQMEDBAAYDTp0qZNEwCgejXr1q0DDBAwQMAAAQMEBACgezfv3r0JAAgufDhx4gECCBggYICAAQECAIgufTp16gQAYM+ufTt37QG+fwcgfjz58uUJAEivfj379u7fw2dPAAD9+vbv48+vf/99AgAAAhA4kGBBgwcRJlS4kGHDhAQARJQ4kWJFixcxUiQAgJVjR48fQYYUOfIjAQAnUaZUuZJlS5cqCQCQOZNmTZs3ceasSQBAT58/gQYVOpQoUAIAkCZVupRpU6dPlxIAMJVqVatXsWbVapUAAK9fwYYVO5Zs2bAEAKRVu5ZtW7dv4bIlAIBuXbt38ebVu/cuAQB/AQcWPJhwYcOCCQBQvJhxY8ePIUduTABAZcuXMWfWvJkzZgIBAQA7\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lnq9Hzo1Po6X"
      },
      "source": [
        "## Next steps\n",
        "\n",
        "This tutorial demonstrated how to implement the actor-critic method using Tensorflow.\n",
        "\n",
        "As a next step, you could try training a model on a different environment in OpenAI Gym. \n",
        "\n",
        "For additional information regarding actor-critic methods and the Cartpole-v1 problem, you may refer to the following resources:\n",
        "\n",
        "- [Actor Critic Method](https://hal.inria.fr/hal-00840470/document)\n",
        "- [Actor Critic Lecture (CAL)](https://www.youtube.com/watch?v=EKqxumCuAAY&list=PLkFD6_40KJIwhWJpGazJ9VSj9CFMkb79A&index=7&t=0s)\n",
        "- [Cartpole learning control problem \\[Barto, et al. 1983\\]](http://www.derongliu.org/adp/adp-cdrom/Barto1983.pdf) \n",
        "\n",
        "For more reinforcement learning examples in TensorFlow, you can check the following resources:\n",
        "- [Reinforcement learning code examples (keras.io)](https://keras.io/examples/rl/)\n",
        "- [TF-Agents reinforcement learning library](https://www.tensorflow.org/agents)\n"
      ]
    }
  ]
}