Q_learning.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Notebook by Philippe Sayegh 260637812 based on the "
      ],
      "metadata": {
        "id": "VMlWrJGCQKs8"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lRXPubi9tWRa"
      },
      "outputs": [],
      "source": [
        "! pip install pettingzoo==1.22.3\n",
        "! pip install pymunk\n",
        "! pip install multi_agent_ale_py\n",
        "! pip install \"autorom[accept-rom-license]\"\n",
        "\n",
        "! apt-get install -y xvfb"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aj7qn7U7Om_f"
      },
      "outputs": [],
      "source": [
        "! AutoROM --accept-license"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EUdpZ_JxtPhE",
        "outputId": "bd8ee074-2d28-4608-e4fa-83b5f60399b7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ],
      "source": [
        "#imports\n",
        "import time\n",
        "import numpy as np\n",
        "import cv2\n",
        "\n",
        "\n",
        "from pettingzoo import AECEnv\n",
        "from pettingzoo.atari import space_invaders_v2\n",
        "from typing import Any, Dict, List, Tuple, Optional\n",
        "import matplotlib.pyplot as plt\n",
        "from tqdm.notebook import tqdm_notebook\n",
        "\n",
        "import torch\n",
        "import os\n",
        "from torch.nn.functional import normalize\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(device)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_JzqAAAbqQvy"
      },
      "source": [
        "## Q-learning with LFA and epsilon-greedy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BU9omeSJ1UgQ"
      },
      "outputs": [],
      "source": [
        "# Setup\n",
        "\n",
        "#To use random baseline\n",
        "RANDOM_BOTH = False\n",
        "#To use Q-learning with LFA and epsilon-greedy policy\n",
        "QL_BOTH = True\n",
        "\n",
        "px_per_img = 160*210\n",
        "use_rgb  = True\n",
        "\n",
        "runs = 2\n",
        "episodes = 100\n",
        "action_padding = 16800\n",
        "epsilon = 0.9\n",
        "gamma = 0.99\n",
        "lr = 0.01\n",
        "incr_clip = 1\n",
        "\n",
        "start_lr = lr\n",
        "\n",
        "num_steps_per_ep = np.zeros(episodes)\n",
        "\n",
        "rewards_per_run_ep = np.zeros((episodes, runs))\n",
        "rewards_per_run_ep_disc = np.zeros((episodes, runs))\n",
        "\n",
        "rewards_eps_mean = np.zeros((episodes))\n",
        "rewards_eps_mean_disc = np.zeros((episodes))\n",
        "\n",
        "rewards_eps_std_err = np.zeros((episodes))\n",
        "rewards_eps_std_err_disc = np.zeros((episodes))\n",
        "\n",
        "if use_rgb:\n",
        "  px_per_img *= 3\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Transform rgb np array to grayscale\n",
        "\n",
        "def rgb_to_gray(rgb_image):\n",
        "    r, g, b = rgb_image[:, :, 0], rgb_image[:, :, 1], rgb_image[:, :, 2]\n",
        "    gray_image = 0.2989 * r + 0.5870 * g + 0.1140 * b\n",
        "    gray_image = np.round(gray_image).astype(np.uint8)\n",
        "    return gray_image"
      ],
      "metadata": {
        "id": "lHqpUG9e_bdB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2Qr5HIMdrv5H"
      },
      "outputs": [],
      "source": [
        "# Implement epsilon greedy policy\n",
        "def epsilon_greedy(cs, w, agent_name, env, epsilon, action_padding):\n",
        "\n",
        "  if not use_rgb:\n",
        "    cs = rgb_to_gray(cs.get(agent_name))\n",
        "  else:\n",
        "    cs = cs.get(agent_name)\n",
        "  cs = torch.tensor(cs.flatten()).to(device)\n",
        "  \n",
        "  # Choose action using epsilon greedy policy\n",
        "  threshold = np.random.rand()\n",
        "  if 1.0-epsilon > threshold:\n",
        "\n",
        "    action = int(np.floor(np.random.rand() * 6))\n",
        "    #build feature vector with action\n",
        "    x_csa = torch.zeros(px_per_img+action_padding).to(device)\n",
        "    x_csa[:px_per_img] = cs\n",
        "    x_csa[px_per_img:] = torch.ones(action_padding).to(device) * action\n",
        "    q_csa = torch.dot(w, x_csa)\n",
        "    \n",
        "  else:\n",
        "\n",
        "    # Compute the Q value of all 6 possible actions at this state\n",
        "\n",
        "    x_cs0 = torch.zeros(px_per_img+action_padding, device=device)\n",
        "    x_cs1 = torch.zeros(px_per_img+action_padding, device=device)\n",
        "    x_cs2 = torch.zeros(px_per_img+action_padding, device=device)\n",
        "    x_cs3 = torch.zeros(px_per_img+action_padding, device=device)\n",
        "    x_cs4 = torch.zeros(px_per_img+action_padding, device=device)\n",
        "    x_cs5 = torch.zeros(px_per_img+action_padding, device=device)\n",
        "\n",
        "    x_cs0[:px_per_img] = cs\n",
        "    x_cs1[:px_per_img] = cs\n",
        "    x_cs2[:px_per_img] = cs\n",
        "    x_cs3[:px_per_img] = cs\n",
        "    x_cs4[:px_per_img] = cs\n",
        "    x_cs5[:px_per_img] = cs\n",
        "\n",
        "    x_cs0[px_per_img:] = torch.ones(action_padding, device=device) * 0 * 51\n",
        "    x_cs1[px_per_img:] = torch.ones(action_padding, device=device) * 1 * 51\n",
        "    x_cs2[px_per_img:] = torch.ones(action_padding, device=device) * 2 * 51\n",
        "    x_cs3[px_per_img:] = torch.ones(action_padding, device=device) * 3 * 51\n",
        "    x_cs4[px_per_img:] = torch.ones(action_padding, device=device) * 4 * 51\n",
        "    x_cs5[px_per_img:] = torch.ones(action_padding, device=device) * 5 * 51\n",
        "\n",
        "    x_cs0 = normalize(x_cs0, dim=0)\n",
        "    x_cs1 = normalize(x_cs1, dim=0)\n",
        "    x_cs2 = normalize(x_cs2, dim=0)\n",
        "    x_cs3 = normalize(x_cs3, dim=0)\n",
        "    x_cs4 = normalize(x_cs4, dim=0)\n",
        "    x_cs5 = normalize(x_cs5, dim=0)\n",
        "\n",
        "    xs = torch.stack([x_cs0, x_cs1, x_cs2, x_cs3, x_cs4, x_cs5])\n",
        "\n",
        "    # Compute Q-values\n",
        "    q_vals = torch.matmul(xs, w)\n",
        "\n",
        "    q_vals = q_vals.cpu()\n",
        "\n",
        "\n",
        "    # Choose best action\n",
        "    max_idx = torch.argmax(q_vals)\n",
        "\n",
        "    q_csa = q_vals[max_idx]\n",
        "    x_csa = xs[max_idx]\n",
        "    action = max_idx.item()\n",
        "\n",
        "\n",
        "  return (q_csa, x_csa, action)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UEPe5XYmDAsC"
      },
      "outputs": [],
      "source": [
        "# This function performs Q-learning with LFA for a single agent\n",
        "def ql_lfa(w, ns, agent_name, q_csa, x_csa, r, alpha, gamma, action_padding):\n",
        "\n",
        "  if not use_rgb:\n",
        "    ns = rgb_to_gray(ns.get(agent_name))\n",
        "  else:\n",
        "    ns = ns.get(agent_name)\n",
        "  ns = torch.tensor(ns.flatten()).to(device)\n",
        "\n",
        "  # Find the action at the next state that yields the highest Q value\n",
        "\n",
        "  x_ns0 = torch.zeros(px_per_img+action_padding, device=device)\n",
        "  x_ns1 = torch.zeros(px_per_img+action_padding, device=device)\n",
        "  x_ns2 = torch.zeros(px_per_img+action_padding, device=device)\n",
        "  x_ns3 = torch.zeros(px_per_img+action_padding, device=device)\n",
        "  x_ns4 = torch.zeros(px_per_img+action_padding, device=device)\n",
        "  x_ns5 = torch.zeros(px_per_img+action_padding, device=device)\n",
        "\n",
        "  x_ns0[:px_per_img] = ns\n",
        "  x_ns1[:px_per_img] = ns\n",
        "  x_ns2[:px_per_img] = ns\n",
        "  x_ns3[:px_per_img] = ns\n",
        "  x_ns4[:px_per_img] = ns\n",
        "  x_ns5[:px_per_img] = ns\n",
        "\n",
        "  x_ns0[px_per_img:] = torch.ones(action_padding, device=device) * 0 * 51\n",
        "  x_ns1[px_per_img:] = torch.ones(action_padding, device=device) * 1 * 51\n",
        "  x_ns2[px_per_img:] = torch.ones(action_padding, device=device) * 2 * 51\n",
        "  x_ns3[px_per_img:] = torch.ones(action_padding, device=device) * 3 * 51\n",
        "  x_ns4[px_per_img:] = torch.ones(action_padding, device=device) * 4 * 51\n",
        "  x_ns5[px_per_img:] = torch.ones(action_padding, device=device) * 5 * 51\n",
        "\n",
        "  x_ns0 = normalize(x_ns0, dim=0)\n",
        "  x_ns1 = normalize(x_ns1, dim=0)\n",
        "  x_ns2 = normalize(x_ns2, dim=0)\n",
        "  x_ns3 = normalize(x_ns3, dim=0)\n",
        "  x_ns4 = normalize(x_ns4, dim=0)\n",
        "  x_ns5 = normalize(x_ns5, dim=0)\n",
        "\n",
        "  xs = torch.stack([x_ns0, x_ns1, x_ns2, x_ns3, x_ns4, x_ns5])\n",
        "\n",
        "  # Compute Q-values\n",
        "  q_vals = torch.matmul(xs, w)\n",
        "  \n",
        "\n",
        "  # Save it for the update step\n",
        "  max_idx = torch.argmax(q_vals)\n",
        "\n",
        "  q_nsa = q_vals[max_idx]\n",
        "  x_nsa = xs[max_idx]\n",
        "\n",
        "  \n",
        "  # Update Q(s, action) implicitly through updating its weights\n",
        "  delta = r + gamma * q_nsa - q_csa\n",
        "  w = w + torch.clip(alpha * delta * x_csa, -incr_clip, incr_clip)\n",
        "\n",
        "  return w"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 49,
          "referenced_widgets": [
            "dfed9117f0764c80b502186e430bd49c",
            "13232e74996841a0b4c253154f9c3aaf",
            "e49d7de3da184c12b4a8ff88fbb0b167",
            "8ffab7255d1142e49d9faf713ed238e6",
            "596b5bf3db26456cade8a073cc4e9d17",
            "d1f2e1d026084530972bf942a4c0f557",
            "e0f3033b89ad42e68248ceb0ba4f7346",
            "c48e6dc5554a440bb6c461169b08e7bd",
            "d1db8966138845039fcde3416c99c6bc",
            "c4804329fdec4925bc43d1690a44ce64",
            "1428627440f641c693921ed25ebd7edc"
          ]
        },
        "id": "5QRFQ5rwS_ib",
        "outputId": "1e152e10-0a05-4959-e23b-7a05caa79ed1"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/100 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "dfed9117f0764c80b502186e430bd49c"
            }
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Main loop\n",
        "\n",
        "env = space_invaders_v2.parallel_env(render_mode=\"rgb_array\")\n",
        "\n",
        "\n",
        "TRAIN = True\n",
        "record_video = False\n",
        "video_prefix = \"no_learn_run\"\n",
        "\n",
        "if TRAIN:\n",
        "  w1 = 0\n",
        "  w2 = 0\n",
        "\n",
        "for run in range(runs):\n",
        "  #Init weight vectors for both agents\n",
        "  if TRAIN:\n",
        "    w1 = torch.from_numpy(np.random.uniform(low=-0.001, high=0.001, size=(px_per_img+action_padding))).to(torch.float).to(device)\n",
        "    w2 = torch.from_numpy(np.random.uniform(low=-0.001, high=0.001, size=(px_per_img+action_padding))).to(torch.float).to(device)\n",
        "  for ep in tqdm_notebook(range(episodes)):\n",
        "    \n",
        "    obs = env.reset()\n",
        "    # Reset reward accumulators\n",
        "    rewards_ep_acc = 0\n",
        "    rewards_ep_acc_disc = 0\n",
        "    game_steps = 0  \n",
        "\n",
        "    # Video recording init code\n",
        "    video_writer = None\n",
        "    if record_video and ep % 100 == 0:\n",
        "        video_path = os.path.join(os.getcwd(), f\"{video_prefix}_q_lfa_epsilon_episode_{ep}_gamma_{gamma}.mp4\")\n",
        "        print(f\"Recording video to {video_path}\")\n",
        "        frame_size = (160, 210)  # (width, height)\n",
        "        video_writer = cv2.VideoWriter(video_path, cv2.VideoWriter_fourcc(*'MP4V'), env.metadata[\"render_fps\"], frame_size)\n",
        "\n",
        "    # Main game loop running until termination or truncation of all agents\n",
        "    while env.agents:\n",
        "      # If we're running an uniform random policy\n",
        "      if RANDOM_BOTH == True:\n",
        "        actions = {agent: env.action_space(agent).sample() for agent in env.agents}\n",
        "        obs, rewards, terminations, truncations, infos = env.step(actions)\n",
        "      # If we're running a Q-learning policy for both agents\n",
        "      if QL_BOTH == True:\n",
        "        # Choose actions\n",
        "        (q_csa_1, x_csa_1, action_1) = epsilon_greedy(obs, w1, \"first_0\", env, epsilon, action_padding)      \n",
        "        (q_csa_2, x_csa_2, action_2) = epsilon_greedy(obs, w2, \"second_0\", env, epsilon, action_padding)\n",
        "        actions = {\"first_0\": action_1, \"second_0\": action_2}\n",
        "        # Take actions\n",
        "        obs, rewards, terminations, truncations, infos = env.step(actions)\n",
        "        if TRAIN:\n",
        "          # Update weights\n",
        "          w1 = ql_lfa(w1, obs, \"first_0\",  q_csa_1, x_csa_1, rewards.get(\"first_0\"), lr, gamma, action_padding)\n",
        "          w2 = ql_lfa(w2, obs, \"second_0\", q_csa_2, x_csa_2, rewards.get(\"second_0\"), lr, gamma, action_padding)\n",
        "      \n",
        "      \n",
        "      # Accumulate the rewards for this episode and run throughout the moves\n",
        "      rewards_ep_acc += rewards.get('first_0') + rewards.get('second_0')\n",
        "      rewards_ep_acc_disc += rewards.get('first_0') + rewards.get('second_0') * (0.999 ** game_steps)\n",
        "\n",
        "      # Video recording code\n",
        "      if record_video:\n",
        "        frame = env.render()\n",
        "        if record_video and ep % 100 == 0 and video_writer is not None:\n",
        "            video_writer.write(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))  # Convert to BGR format\n",
        "\n",
        "      # Count steps for this game playthrough\n",
        "      game_steps += 1\n",
        "    num_steps_per_ep[ep] = game_steps\n",
        "\n",
        "    # Save accumulated rewards for this episode and run\n",
        "    rewards_per_run_ep[ep][run] = rewards_ep_acc\n",
        "    rewards_per_run_ep_disc[ep][run] = rewards_ep_acc_disc\n",
        "    # Decay LR\n",
        "    if ep%10 == 0:\n",
        "      lr *= 0.1\n",
        "    if video_writer is not None:    \n",
        "        video_writer.release()\n",
        "\n",
        "    \n",
        "# Compute performance metrics\n",
        "rewards_eps_mean = np.mean(rewards_per_run_ep, axis=1)\n",
        "rewards_eps_mean_disc = np.mean(rewards_per_run_ep_disc, axis=1)\n",
        "rewards_eps_std_err = np.std(rewards_per_run_ep, axis=1) / np.sqrt(runs) \n",
        "rewards_eps_std_err_disc = np.std(rewards_per_run_ep_disc, axis=1) / np.sqrt(runs) \n",
        "\n",
        "env.close()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BbfL9c4zKiYX"
      },
      "source": [
        "## Results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lUXJkVl4dakv"
      },
      "outputs": [],
      "source": [
        "# Save some results for the report\n",
        "\n",
        "ep_total_rewards = rewards_per_run_ep[:, 0]\n",
        "ep_total_rewards_discounted = rewards_per_run_ep_disc[:, 0]\n",
        "\n",
        "q_lfa_results = np.array([ep_total_rewards, ep_total_rewards_discounted, num_steps_per_ep])\n",
        "\n",
        "np.save('q_lfa_results.npy', q_lfa_results)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 509
        },
        "id": "hQgMzyp5C9ei",
        "outputId": "49f7a952-1276-4634-8a88-2b7263bade6e"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Reward')"
            ]
          },
          "metadata": {},
          "execution_count": 24
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Build non-discounted mean reward plot\n",
        "ig, ax = plt.subplots()\n",
        "ax.plot(rewards_eps_mean, color='blue', label=\"mean\")\n",
        "plt.fill_between(range(len(rewards_eps_mean)),\n",
        "                 rewards_eps_mean - rewards_eps_std_err,\n",
        "                 rewards_eps_mean + rewards_eps_std_err,\n",
        "                 alpha=0.3, color='blue', label=\"std err\")\n",
        "\n",
        "plt.title(f\"Mean total reward and std error per episode over {runs} runs, \\nlr {start_lr}, gamma {gamma}, incr clip +-{incr_clip}\")\n",
        "plt.legend(loc='upper right')\n",
        "\n",
        "plt.xlabel(\"Episode\")\n",
        "plt.ylabel(\"Reward\")\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Build discounted mean reward plot\n",
        "ig, ax = plt.subplots()\n",
        "ax.plot(rewards_eps_mean_disc, color='red', label=\"mean\")\n",
        "\n",
        "plt.fill_between(range(len(rewards_eps_mean_disc)),\n",
        "                 rewards_eps_mean_disc - rewards_eps_std_err_disc,\n",
        "                 rewards_eps_mean_disc + rewards_eps_std_err_disc,\n",
        "                 alpha=0.3, color='red', label=\"std err\")\n",
        "\n",
        "plt.title(f\"Mean total discounted reward and std err per episode over {runs} runs, \\nlr {start_lr}, gamma {gamma}, incr clip +-{incr_clip}\")\n",
        "plt.legend(loc='upper right')\n",
        "\n",
        "plt.xlabel(\"Episode\")\n",
        "plt.ylabel(\"Discounted Reward\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 509
        },
        "id": "f6-cnphNJexP",
        "outputId": "8f5c9cd5-2bdb-4d4c-abb6-0e159db90cb1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Discounted Reward')"
            ]
          },
          "metadata": {},
          "execution_count": 23
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 445
        },
        "id": "hHFBY6aoIXmB",
        "outputId": "e197d1bf-c141-4c3d-c09d-58ca5c1e716f"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7f98a23cfd90>]"
            ]
          },
          "metadata": {},
          "execution_count": 23
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjAAAAGdCAYAAAAMm0nCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB2fklEQVR4nO2deZgU1b3+356tGRhmhkVmQBYxGBYlChJh4nJdiGiIiZHkSQwuUTRXLyaCN2rMVa+PXsWrMVyNKHGJ+LtRuZqoUdQggkAIizqCIOhIFAWFARGZGbbZun5/HE/X6Zqq7qruWrvfz/PMUz3dNd1nqqvOeev9fs/3xDRN00AIIYQQEiGKgm4AIYQQQohTKGAIIYQQEjkoYAghhBASOShgCCGEEBI5KGAIIYQQEjkoYAghhBASOShgCCGEEBI5KGAIIYQQEjlKgm6AVyQSCWzfvh09e/ZELBYLujmEEEIIsYGmaWhpacGAAQNQVGTts+StgNm+fTsGDRoUdDMIIYQQkgXbtm3DwIEDLV/PWwHTs2dPAOIAVFZWBtwaQgghhNihubkZgwYNSo7jVuStgJFho8rKSgoYQgghJGJkSv9gEi8hhBBCIgcFDCGEEEIiBwUMIYQQQiIHBQwhhBBCIgcFDCGEEEIih2MB89lnn+GCCy5Anz59UF5ejtGjR+Ott95Kvq5pGm6++Wb0798f5eXlmDhxIjZv3pzyHnv27MHUqVNRWVmJ6upqTJs2Dfv27UvZZ/369Tj55JPRrVs3DBo0CHfddVeW/yIhhBBC8g1HAubLL7/EiSeeiNLSUrzyyivYtGkT7rnnHvTq1Su5z1133YX77rsPc+fOxZo1a9CjRw9MmjQJhw4dSu4zdepUbNy4EYsWLcKCBQuwfPly/PznP0++3tzcjDPPPBNDhgxBfX097r77btxyyy146KGHXPiXCSGEEBJ5NAdcf/312kknnWT5eiKR0Gpra7W77747+dzevXu1eDyuPfXUU5qmadqmTZs0ANqbb76Z3OeVV17RYrGY9tlnn2mapmkPPPCA1qtXL621tTXls4cPH267rU1NTRoArampyfbfEEIIISRY7I7fjhyYF154AePGjcOPfvQj9OvXD2PGjMHDDz+cfH3Lli1obGzExIkTk89VVVVh/PjxWLVqFQBg1apVqK6uxrhx45L7TJw4EUVFRVizZk1yn1NOOQVlZWXJfSZNmoSGhgZ8+eWXpm1rbW1Fc3Nzyg8hhBBC8hNHAuajjz7Cgw8+iKOOOgoLFy7ElVdeiV/+8pd4/PHHAQCNjY0AgJqampS/q6mpSb7W2NiIfv36pbxeUlKC3r17p+xj9h7qZxiZNWsWqqqqkj9cB4kQQgjJXxwJmEQigbFjx+KOO+7AmDFj8POf/xyXX3455s6d61X7bHPDDTegqakp+bNt27agm0QIIYQQj3AkYPr3749Ro0alPDdy5Ehs3boVAFBbWwsA2LlzZ8o+O3fuTL5WW1uLXbt2pbze0dGBPXv2pOxj9h7qZxiJx+PJdY+4/hEhhBCS3zgSMCeeeCIaGhpSnvvggw8wZMgQAMDQoUNRW1uLxYsXJ19vbm7GmjVrUFdXBwCoq6vD3r17UV9fn9xnyZIlSCQSGD9+fHKf5cuXo729PbnPokWLMHz48JQZT4QQQkgh8sknwF13AXv3Bt2SAHGSGfzGG29oJSUl2u23365t3rxZe+KJJ7Tu3btrf/rTn5L73HnnnVp1dbX217/+VVu/fr32/e9/Xxs6dKh28ODB5D5nnXWWNmbMGG3NmjXaihUrtKOOOko7//zzk6/v3btXq6mp0S688ELt3Xff1ebPn691795d+8Mf/mC7rZyFRAghJF/5t3/TNEDT7r8/6Ja4j93x25GA0TRNe/HFF7VjjjlGi8fj2ogRI7SHHnoo5fVEIqHddNNNWk1NjRaPx7UzzjhDa2hoSNnniy++0M4//3ytoqJCq6ys1C655BKtpaUlZZ933nlHO+mkk7R4PK4dfvjh2p133umonRQwhBBC8pWf/lQImDvuCLol7mN3/I5pmqYF6wF5Q3NzM6qqqtDU1MR8GEIIIXnFj34E/PnPwK23AjfdFHRr3MXu+M21kAghhJCIIVNEOzqCbUeQUMAQQgghEaOtTWwpYAghhBASGaQD09kZbDuChAKGEEIIiRh0YChgCCGEkMjBHBgKGEIIISRySAeGISRCCCGERAY6MBQwhBBCSOSggKGAIYQQQiIHQ0gUMIQQQkjkoANDAUMIIYREDk6jpoAhhBBCIgcL2VHAEEIIIZGDDgwFDCGEEBI5mANDAUMIIYREDs5CooAhhBBCIkUiIX4AOjCEEEIIiQgyfARQwBBCCCEkIsjwEcAQEiGEEEIiAh0YAQUMIYQQEiFUB4YChhBCCCGRQHVgGEIihBBCSCSgAyOggCGEEEIiBHNgBBQwhBBCSISgAyOggCGEEEIiBHNgBBQwhBBCSIRgCElAAUMIIYRECIaQBBQwhBBCSIRgCElAAUMIIYRECDowAgoYQgghJEIwB0ZAAUMIIYRECC7mKKCAIYQQQiIEHRgBBQwhhBASIZgDI6CAIYQQQiIEZyEJKGAIIYSQCMEQkoAChhBCCIkQaghJ04BEIri2BAkFDCGEEBIhVAcGKNwwEgUMIYQQEiFUBwYo3DASBQwhhBASIYwODAUMIYQQQkKP0YFhCIkQQgghoYcOjIAChhBCCIkQFDACChhCCCEkQjCJV0ABQwghhEQITqMWUMAQQgghEYIOjIAChhBCCIkQzIERUMAQQgghEYLTqAUUMIQQQkiEoAMjoIAhhBBCIgRzYAQUMIQQQkiE4CwkAQUMIYQQEiEYQhJQwBBCCCERgiEkAQUMIYQQEiEYQhJQwBBCfOf3vweeey7oVhASTejACEqCbgAhpLDYtg345S+BPn2AH/wg6NYQEj2YAyOgA0MI8ZWmJrHduxfQtECbQkgkYSE7AQUMIcRXWlvFtrOz650kISQz8rop+SqGQgeGEEJ8QAoYADh4MLh2EBJVpANTXi62FDA2uOWWWxCLxVJ+RowYkXz90KFDmD59Ovr06YOKigpMmTIFO3fuTHmPrVu3YvLkyejevTv69euHa6+9Fh2Go7906VKMHTsW8Xgcw4YNw7x587L/DwkhoUIVMAcOBNcOQqKKdGCkgGEIySZHH300duzYkfxZsWJF8rWZM2fixRdfxDPPPINly5Zh+/btOO+885Kvd3Z2YvLkyWhra8PKlSvx+OOPY968ebj55puT+2zZsgWTJ0/GaaedhnXr1mHGjBm47LLLsHDhwhz/VUJIGKADQ0huGAVMoTowjmchlZSUoLa2tsvzTU1NePTRR/Hkk0/i9NNPBwA89thjGDlyJFavXo0JEybg1VdfxaZNm/Daa6+hpqYGxx13HG677TZcf/31uOWWW1BWVoa5c+di6NChuOeeewAAI0eOxIoVKzB79mxMmjQpx3+XEBI0dGAIyQ2GkASOHZjNmzdjwIABOPLIIzF16lRs3boVAFBfX4/29nZMnDgxue+IESMwePBgrFq1CgCwatUqjB49GjU1Ncl9Jk2ahObmZmzcuDG5j/oech/5Hla0traiubk55YcQEj7owBCSGwwhCRwJmPHjx2PevHn429/+hgcffBBbtmzBySefjJaWFjQ2NqKsrAzV1dUpf1NTU4PGxkYAQGNjY4p4ka/L19Lt09zcjINpertZs2ahqqoq+TNo0CAn/xohxCcOHdIf04EhxBmJhC5YuncX20J1YByFkM4+++zk42984xsYP348hgwZgqeffhrlUgoGxA033IBrrrkm+XtzczNFDCEhhA4MIdmjlh5gCCkHqqur8fWvfx3//Oc/UVtbi7a2Nuzduzdln507dyZzZmpra7vMSpK/Z9qnsrIyrUiKx+OorKxM+SGEhA/mwBCSPWoROwqYHNi3bx8+/PBD9O/fH8cffzxKS0uxePHi5OsNDQ3YunUr6urqAAB1dXXYsGEDdu3aldxn0aJFqKysxKhRo5L7qO8h95HvQQiJNnRgCMkeMweGOTA2+NWvfoVly5bh448/xsqVK/GDH/wAxcXFOP/881FVVYVp06bhmmuuweuvv476+npccsklqKurw4QJEwAAZ555JkaNGoULL7wQ77zzDhYuXIgbb7wR06dPRzweBwBcccUV+Oijj3Ddddfh/fffxwMPPICnn34aM2fOdP+/J4T4Dh0YQrJHOjCxGPDVsFmwDoyjHJhPP/0U559/Pr744gscdthhOOmkk7B69WocdthhAIDZs2ejqKgIU6ZMQWtrKyZNmoQHHngg+ffFxcVYsGABrrzyStTV1aFHjx64+OKLceuttyb3GTp0KF566SXMnDkT9957LwYOHIhHHnmEU6gJyRPowBCSPdKBKS3lUgKOBMz8+fPTvt6tWzfMmTMHc+bMsdxnyJAhePnll9O+z6mnnoq1a9c6aRohJCLQgSEke6SAKSvTBQxDSIQQ4gMUMIRkjwwhlZYCxcXicaE6MBQwhBBfYQiJkOxhCEmHAoYQ4it0YAjJHunAMIREAUMI8Rm1Ei8dGEKcoTowDCERQoiP0IEhJHvMHBgKGEII8QHmwBCSPWY5MAwhEUKID9CBISR7VAeGISSSdzz7LDBmDPD++0G3hJCu0IEhJHs4C0mHAiYPefJJYN064JVXgm4JIV2hA0NI9rCQnQ4FTB4i72p5d0vCCB0YQrKHhex0KGDyEDko8O6WhBE6MIRkD0NIOhQweQgFDAkzdGAIyR4WstOhgMlDKGBImKEDQ0j2sJCdDgVMHkIBQ8KM0YHRtODaQkjUYCE7HQqYPESWaqeAIWFEXUogkdA7ZEJIZljITocCJg+hA0PCjOrAAMyDIcQJdGB0KGDyEAoYElYSCf0OUsLzlBD7MAdGhwImD2EdGBJWzMJFPE8JsY9ZITsKGJIXtLfr8VDe2ZKwoYaPqqrElucpIfZRC9kxB4bkFWqCJAcGEjbMBAwdGELswxCSDgVMnqEOBhQwJGxIAVNaCvToIR7zPCXEPkzi1aGAyTMoYEiYkQImHge6dxeP6cAQYh9Oo9ahgMkzKGBImFEFTHm5eMzzlBD7qA4MQ0gkr1AFTEdH1ymrhAQJHRhCcoOLOepQwOQZahIvwLtbEi7k+UkHhpDs4GKOOhQweYbxbpZ3tyRM0IEhJDc4C0mHAibPMA4GvLslYUIKmG7d6MAQkg0sZKdDAZNnUMCQMEMHhpDcYCE7HQqYPIMCxj2amoC//a1wOwcv4CwkQnKDISQdCpg8g0m87nH99cDZZwNPPx10S/IHOjCE5AYL2elQwOQZdGDc49NPxXblymDbkU/QgSEkN1jITocCJs+ggHEPeSw3bAi2HfkEHRjiJoU4cLOQnQ4FTJ5BAeMeMhy3fj2gacG2JV+gA0PcYu1aoLoauPvuoFviLyxkp0MBk2ewDox7yGP35ZfA9u3BtiVfoAND3OLvfwf27QOWLAm6Jf5iNo26EJ0ogAIm72ASr3uox3L9+uDakU+wEi9xi927xdbY5+U7ZtOo6cCQvIAhJPdQO0bmwbgDHRjiFlLAFNr5ozowMgems7Mww9wUMHkGBYx7qMeSDow7sBIvcYsvvhBbOjCCQgwjUcDkGXLQrawUWw4O2UMHxn3owBC3KHQHhgKGAibvkBdz795iSwGTPWrH+N57esdBsoezkIhbFKqAMZtGDRRmHgwFTJ4hL+Y+fcSWg0N2aJo+2BYVCfHS0BBsm/IBOjDELQo1hGTlwFDAkMgjL2YKmNxQO8WjjxZbhpFyx8qBKcQERJI9mlaYDkwioYeK1GnUAENIJA8whpAK6eJ2E1XAnHCC2DKRN3fMHBhN021xQuxw4IB+LhWSA6OGsUtLhTssoQNDIg9DSO4gj2NxMTBmjHhMByZ3zBwYgOcpcYZ0XwAxcBfK4K0KmLIyIBYr7OUEKGDyDAoYd5B3deXlwOjR4jEFTO6oAkaN4dMpJE5QBQxQOOeP6lSWloptIVfjpYDJMyhg3EEex27ddAGzdSuwd29gTcoL1Eq8AGcikeyQCbySQgkjqQ6MdF7owJC8gUm87qA6ML16AQMHit/ffTe4NuUDqgMDcCYSyY5Cd2Bk+Ago7OUEKGDyDNaBcQfVgQGAb3xDbJnImxtqJV6ADgzJDqMDUygCRp1CLWEIiUSGP/4ROPnkrncgQGoyGwVMbqgODMA8GLegA0PcwNj/FUoISXVgJAwhkcjw0EPAihXmS8irgwBDSLlhdGAoYNzBKGDowISTRAJYuhRoagq6JeYUaggpnQNDAUNCj+zo9+3r+pp6EUsHprOTJfCzwejAyBDShg0supYLdGCiwSuvAKedBsycGXRLzCnUJF4zB4YhJOI569YJ5yRXpIBpaen6mjrDo6Ki698Q+xgdmOHDRUfR3CxmI5HsoAMTDT75RGw/+ijYdlhBB0Z/jiEk4imaBnz728AZZ4gBMBfSCRh5EZeXixNcntgcHJxjdGDKyoCRI8VjJvJmDx2YaLB/v9jm2l95RaEn8Zo5MBQwxBPa28UdQ1tb7nVE5IWaLoTUrZuYYicHBwoY5xgdGIB5MLmiLhlABybcyO8jrAJGOjBVVWJbaCEkzkISUMD4gHp3IO9As8WuA6NuOTg4x+jAAKl5MMQ5ahVRowPDczRcREXAyPpMhebAMIQkoIDxAbVzzmXRuo4O/e/TOTBy0OXgkD3pHBiGkLJDvUs2OjCFMgBFhTALmAMH9HNJCphCc2AYQhJQwPiA2jnnImDU90mXxEsBkztmDsyIEWL74Yf+tycfUN1HOjDhRubAtLbm7hq7jXRfysqAfv3E40IRwCxklwoFjA+onXMunUEmAUMHxj2kgFEdmMpKsW1tLcy7nVyR535pKVD0Vc9DByacqH2GWV8TJDKBt0+fwjt/6MCkQgHjA26FkNT3yZTEC3CGRy6YhZDk8VRf9xNNAx59FKiv9/+z3cA4AwmgyA4r6vcRtjCSdGD69tWvz0IJITEHJpWcBMydd96JWCyGGTNmJJ87dOgQpk+fjj59+qCiogJTpkzBzp07U/5u69atmDx5Mrp3745+/frh2muvRYfh6C9duhRjx45FPB7HsGHDMG/evFyaGihuhZAy3RXRgXEPsxCS+lha7H6ydi1w2WXAJZf4/9luYCZgCu0OOipEQcDQgRHQgcmCN998E3/4wx/wDTk14ytmzpyJF198Ec888wyWLVuG7du347zzzku+3tnZicmTJ6OtrQ0rV67E448/jnnz5uHmm29O7rNlyxZMnjwZp512GtatW4cZM2bgsssuw8KFC7NtbqC4FUKigPEPMwcm6Knp8j5g8+ZoVgOmAxMdwixgZAiJDoyAOTAO2bdvH6ZOnYqHH34YvXr1Sj7f1NSERx99FL/73e9w+umn4/jjj8djjz2GlStXYvXq1QCAV199FZs2bcKf/vQnHHfccTj77LNx2223Yc6cOWj7Sl7OnTsXQ4cOxT333IORI0fiqquuwg9/+EPMnj3bhX/Zf7xI4jULITGJ1z3MHBgg2GMqv/NDh4A9e/z//FyhAxMdVIcxbAJGDSEV2vljVsiOISSHTJ8+HZMnT8bEiRNTnq+vr0d7e3vK8yNGjMDgwYOxatUqAMCqVaswevRo1NTUJPeZNGkSmpubsXHjxuQ+xveeNGlS8j3MaG1tRXNzc8pPWPAiB4Z1YLzFzIEBgB49xDaIEJIqWrdt8//zc4UOTHSIggNTyCEkLuYocCxg5s+fj7fffhuzZs3q8lpjYyPKyspQXV2d8nxNTQ0aGxuT+6jiRb4uX0u3T3NzMw5anKmzZs1CVVVV8mfQoEFO/zXPcKuQndqptLd3FUNWSbwcHJwTRgdGFa35ImAKbQCKCmEWMEziZQhJ4kjAbNu2DVdffTWeeOIJdDPemgbMDTfcgKampuTPthD18F44MEBXF4Y5MO5h5cCEIYQE5I+A4TkaTqIgYArZgWEISeBIwNTX12PXrl0YO3YsSkpKUFJSgmXLluG+++5DSUkJampq0NbWhr2GBX927tyJ2tpaAEBtbW2XWUny90z7VFZWotx4S/wV8XgclZWVKT9hwS0BY7xIKWC8w8qBYQgpe9TV0iWFNgBFhTDnwKhJvPL8oQNDAZORM844Axs2bMC6deuSP+PGjcPUqVOTj0tLS7F48eLk3zQ0NGDr1q2oq6sDANTV1WHDhg3YtWtXcp9FixahsrISo0aNSu6jvofcR75H1PAihAR0TeS1EjAcHJxDB8Z95LlvVlsnbCK7vR049VTgyiuDbon/tLfrAyUQvkJ2ZiGkQunj0k2jLsQQUomTnXv27Iljjjkm5bkePXqgT58+yeenTZuGa665Br1790ZlZSV+8YtfoK6uDhMmTAAAnHnmmRg1ahQuvPBC3HXXXWhsbMSNN96I6dOnI/7VrdkVV1yB+++/H9dddx0uvfRSLFmyBE8//TReeuklN/5n3/ErhMRZSO4RxhwYVcB8+qn/n58rUcqBaWgAli0Dli8HZs0CDGl9eY3xuwibA6OGkGTbwnb+eAUL2aXieiXe2bNn47vf/S6mTJmCU045BbW1tXj22WeTrxcXF2PBggUoLi5GXV0dLrjgAlx00UW49dZbk/sMHToUL730EhYtWoRjjz0W99xzDx555BFMmjTJ7eb6glcODENI3pFpFlLQAibKDoxVDkyYatvIKLimAWvWBNoU3zGe22ESMAcO6NdmISbxspBdKo4cGDOWLl2a8nu3bt0wZ84czJkzx/JvhgwZgpdffjnt+5566qlYu3Ztrs0LBV7lwFiFkDgLKXcyOTBB5MCogvXTT4FEQl9TKAqkc2Dk62GZG9DUpD9etQqI6L1TVoRZwMj8l5ISoGfP8Dp4XsFZSKlEqPuLLkHNQmIdmOzQtPDnwLS1AZ9/7n8bciGTgAnTearOQ1i5MrBmBIJRnIdRwPTtKypjF6qA4SwkAQWMDwSdxBumgSEKqCLTahZS0AIGiF4YyUzAlJbqd5BhGoRUAbNmTWHd3YbZgVETeIHCDSFxFpKAAsYH/JpGzSRed1CPs5UDE+Q0ahk2ygcBA4TzPFVDSM3NwKZNwbXFb6IgYPr0EVvVgQlTDpVXMISUCgWMD7i9GrW8aJnE6w1SCMZiqR0FEI4Q0te+JrZRm4lkJWDCGAYwlLJCmlVM8g55bstl7sIkYNQQEqDfYGha6tTvfIWF7FKhgPEBt1ejlqss2E3iDdPAEAVUIRiLpb4WhhDSyJFiSwfGO6SAkddSIeXBSHfxq7qi2LcvPHf3Vg4MUBj9HAvZpUIB4wNuOzD9+omtEwemEOxVt5AOjNmMmKBCSImE/pkjRoht1ASMWSVeINwOzKmnim0hOjD9++vPGW+WgsLowJSV6TcZYTp/vIKF7FKhgPEBt3NgnAqYzs7CsFfdwmoKNRCcW6CK0Kg7MGGa2WWFzIE56yyx/eAD/e4/31FDSHKgDEsYyZjEG4sVViIvC9mlQgHjA36EkDo69BPYKGCMbSDpsZpCDQQXQpLfdSwGfP3r4nFUBUyUHJgjj9Qdr9WrA2uOr8hzu3t3QC4pFzYBI0NIQDjPH69gIbtUKGB8wI8Qknr3IS/o0lJdnVPA2MeOA+N3CEkKmIoKYPBg8Xj79mjZxlHMgamqAuQSbIUSRgqzgDGGkAA6MAwhEc/QNPcL2UkBozowVlN/wzg4hJ10DkxQx1N+1z17ityE4mJxx2VYtD3URNGBqa4GvvUt8bhQEnmlOO/RI3wCptAdGLNCdnRgiGcYQ0a5hJDS5cDI18rKUsvLU8A4J4w5MKoDU1wMDBggfjeGkTo6gB//WKyinItY9oIoOTAyB6a6Wndg3nijMAaJqDkwhSRgzArZMQeGeIaxU852UEkk9AtU5sCYCZgwrZ4cVcKcA1NRIbYDB4qtUcCsXg08/TQwdy5w3nnhstWj4sAcOqS3tbpaJE1XVYnvfP36QJvmC2EVMAcP6u4QQ0j6c3RgiGe4JWDUi9MsiTfT4oNhGRyigB0Hpr3d35ldUqxKATNokNgaBczy5frjl14Cvve98IjXqDgwMnwUi4njXVQETJggniuEPJiwChh1IUfZLiB8AthLOI06FQoYjzFeVNmGkNTO/bDD9PeWqpsOjHvYyYEB/D2mRgfGSsAsWya2P/2pcIsWLQK+851w1PGIigOjJvDKcGwh5cFIlyOsAqZPn9QCk4XuwDCERDzDLQdGzXGprtaflwNTGFdPjirpHJh4XB/UwiBg1OUEOjqAf/xDPL7+euDVV8UAtGwZMGlS17pBfhMVB0bNf5EU0kwk+T2ELYnXLIEXCJ8A9hJOo06FAsZjjBdVtgJGtXXjcV2BGwUMHZjcSefAxGLBTKW248CsXSvaVF0NHHOMcA1ee038vnIl8Mgj/rXXDKeVePftS11U0S/UGUiS8ePFd79lC9DY6H+b/CTsISQ1/wUoLAHDadSpUMB4jOwM5AmXawhJDp5yIJN31VYCRv5OAWOfdA4MEIwoVKdRA+YCRua/nHyy7hJ985vApZeKxzt2eN/OdFhV4jU7Rzs6hAg7+mj/7yzVEJKkslK0B8h/FyasAsZYhVdSSCEkLuaYCgWMx0hhITvDXB0Y2dnLgYwOjPukc2CAYGYiWc1C2rFD77ikgDnllNS/lf9HLlP43SBTCEm9g964EfjkE+Czz/Q7b78wCyEBQgwC+T8TKewCppBDSJyFlAoFjMfIzkB2hrnmwFg5MJlmIVHA2CfdYo5AOEJINTWiE0skREXeRAL4+9/Fa0YBIwVDWAWMmQPz1lv6Y78HT7MQEqAnz8vX85WwFrKzCiEVigOTSOhhIoaQBBQwHqMujAaIkyybE80YQpIOTKYQEgWMc6yOpSSIY2qcRl1UBBx+uHj86afCsfjySzHojB2b+rdh6OA1TRfvdhyYN9/UHwclYNQQkvp7GAZzL6EDE07Usg0MIQlKgm5AvmMMIQGiI7caHK2wEjB2ZyHl+8XtJpkcmDCEkACRB/PxxyIP5vPPxXMnnqjfkUnC4MCozmNUHRg5mAeRWOwnYRUwhZ7EqwoYhpAEdGA8xhhCArILIxlzYOwm8dKBcY5dBybIEBKQmshrlf8C6IIhSAdGFU+ZHJjW1tQ8E78HT6scmEJwYDo69P4pbAKm0JN41XGDhewEFDAeY+bAZHMnbMyBYRKvd9jNgQlyFhJgX8D4mcSracB994klDVTSCRijA7N+ferdJh0Y/1DPaWMOjKYF0yYJQ0j6Yxk2Uh/TgSGuoxaFkrZfLg6MVQ4Mk3jdI5MDE5YQkpyJtHixWJU6Htdnyqj4GUJ64w3g6quBK65IfV5+dklJ6mKjQFcHRs1/AZgD4yfynI7FxHkjBUwiEXwf8uWXYtu7d+rzhSJg1CnUaiVihpCIZ6jCQ9p+bggY1oHxjijMQgJ0B2bjRrEdP968zX5a7LLWjFohGLCegQR0PUfV/BeADoyfqP2MLNooBWfQws2qjyuUEJLZFGrAmxCSpvm71lu2UMB4jHrR5XInbLcODJcSyJ0wF7IzEzASs/AR4K8DI++S9+xJ7VCtqvACqQ6MpukOzJFHii1zYPzDeKMUi4UjDyaR0AdUq0KIheTAqHgRQpo2DejfX58cEFYoYDzGLQcmUx0Y5sC4R9gK2WladASMdC80TYgYiVUVXiD1nP3iC2DTJvH49NPF1u81nDI5MPv3569dbxQwQDgETLpZbHRgxNbNc3LpUnEtrlvn3nt6AQWMx6jCws0QEuvAeEfYHJgDB/QESlXA9O2rd97FxfqCg0b87ODVIm8y6RKwF0ICxJpNiQQwYAAwYoR4zs+Bs71dDw1a5cD43SY/UYvYScIgYNRzN+yrmXuFnyEkeb1KRzWsUMB4jHERRiC3EJLVLKRMSbz5fnG7SSYHxu8cGPkdqwtJyt9lIu/xx6eKG5UgHBgg1X5OJ2BKS/VOWM6mGjdOP8f9HDjVzzIKmNJS/frKVwETVgdGPXeNIZRCETBWISQvHBgKGAIgNfTjhgPDOjDek8mB8TuEpIaP1NkHgC5g/uVfrP/ezzowaodn14EB9PNUCphvfjOYgVMKsIqKrgUBgfxP5A27gInHu14DhR5C8iIHRh5vNQwcRihgPEYVHm7mwDCJ1xs0zb4DE4SAMXLBBcARRwA/+5n13/tZByYbBwbQxeLbb4vtuHHBChij+yLJ90TesAqYdEngdGDElg4McR2vQ0hOHJigC1FFgY4OkYMBhKcSbzoBM20asGULMGqU9d8HFULKxoGRcfygBYwxgVeS7w5MWHNg0iWBF7oD43YOjDrjiwKmwPEqiddpCCmRyH4l7EJCvYsLyywk40KOTlEdGK9FbLYCRj1vjzhCJCgHMXBaTaGW0IEJBjtJ4IcO5fdNml/TqNUbHQqYAsftQnbGOjD79wtxYpW3of7OMFJm0s12kIQphGQH9f/wWsSqHZ6TEJI6YMpqwnRg/CesAsZOCEndLx/xaxo1BQxJ4lYhO6s6MJomOh0rB0ad4UEBkxk1/8WYLCgJUwjJDmqn73UH74YDM26c2MqB8+BB/6qCMgdGbMMmYOyEkIDCEDBWOTBuhZAoYEgSr5YSUEt8t7SkTzxlIq99Mi0jAATnwKgLOTpBFQ1e5sF0dOhtBVIdmHR30IC5A6P+v34Vs6MDI7ZhEzDpzp/SUj2Mks+JvHLc8HoWEgUMASAUsTwZ3BYwsZh+R97UpKtzs8RT1oKxT6aFHIHUHBg/Yu65OjCxmH7ueSlgjIO6mQNjJQzV4z12rNiqdVf8EjCFngMT9iReKwFcCIm8mUJImqZPQMgFChgCIPViyiWEJMNE8n0kckBT73TTCRg6MJlx4sB0dvqTGJ2rgAH86eCNnV02s5CGD08N3/hdzI4OjNiGzYGxK4Dz+SYt0zRqwJ0wkjo+NTW5W+HXbShgPEQVDLnMQmpr0+/01Y5Fdu4UMO5hx4FRvwM/jqkbAsaPqdTG/JEDB/TjYzcHRua/SPwePJkDI7ZhEzCZQpCFIGAyFbID3AkjGfuIMIt1ChgPkRdTPC7yVbIVMOogqXYsRgemrEzPi1GhgLGPHQemrMzfxOhcp1ED/gqYQYP0c126MJkETF2dOHd/8IPU54MSMHRg9OeCWNLBCENI9hwYLwRMmMNIFDAeYuwMsh1E5PsUF6eqb9mx7NoltmFZfDDK2HFgAH+PaVRCSHLw79VL1HEBdHGdaQCaNk0ItSlTUp/3W8DYzYHJVwET9hyYQg4hZcqBAdwJ9xj7CAqYAsUoYHJ1YNS7IqCrgMl0cVPAZMaOAwP4O5U611lIgD8OjOzoqqt1AWPXgQG6nt8AQ0h+ky6E1NbmTzVnMzKFkArZgfE6hEQBU6AY7+azFTDGGjASYwiJDkzu2HVg/KzG62YOjB8OTHU1cNhh4rETAWMGQ0j+ki6EBAQn3OzmUBWiA1NUpNesooAhruF2CCmTA0MBkztOHZioCBg/FnTMJYRkhZ8CJpHQP8fONOp8LFtv1tcUF+uCPWgBwxBSVwcGcLeYHQUMAeCeA2M2hRroOgspk4DJ54vbLayWZDASRAgpKkm8UXVgWlp0UWIVQpLtaW/Pz3CF7GvUHBgg+DwYhpCsC9kB7hazM/YRe/bk/p5eQQHjIVYOjFs5MAwhuU+6isYqfoaQ3JiF5GcdGDUHRp6bmQYgK/wcOKUAi8etv/+KCt2uz8c8GCnIjX1N0AKGISTrEBLg7npIdGAIAGsHxuldsFUOjNGBsep0KWDsk68hJL8dGKsk3kzH1Yg8x/2oxJsp/wUQ+QayTfmWB9PRod9chVXAFHIIySqJF2AIiXiA17OQ5IAmy0fTgckdp9OovQ4haVr0knh79YpmCCnTFGpJvs5EUgf/sAkYhpDSOzBehpDCLGBKMu9CssXtEJJVDoyEAiZ37DowfoWQDh7U8zJymUbtZxJvdbUuqqOUxGvHgQHydyaSPJdjsa7nf9AChiEkew6MGwJGzQM8eDDcAoYOjIe4FULKNAtJYiVgWAfGPmErZCfdl1gsc5vS4XcdmCg6MJlqwEjy1YFR819kno8kLALG6sai0B0YL0JI/fuLLQVMgeJWCClTHRiJEwdm507g7ruBzZudtSXfCVshOylgevQwXybCLn5W4lVzYL74QrgxURIwhe7AhKGgoBGuheSfAyOv1dpasaWAKVCMd/Nuz0IyOjB2k3gPHAAmTQKuuw445hjg5pvz+8J3QtgK2bmR/wJ478AcOqQPMr16AX36iMeJhOgAoyBgCj0HJswChiEk/3NgKGAKHCsHJtsQUq45MDKfYto04J13xIXQ1gbcdhtw9NHAggXO2pWPhG0WkhtTqAHvBYwc/GMxcV6WlekD/e7d7ggYrwvH2Q0h0YHxH4aQ7BWyc1PAyBBSU5M7oSkvoIDxEL9mIUnshJB++1tg/nxxwi9eDPz5z8DAgcCWLcA55wDnn5+fFUbtEtYcmFwFjNcdvLxLq6rSQ11qLZhcBYymeR+usxtCytcFHa2K2AHBCxiGkNIXsvMiB6amRn8urOc6BYyHuBVCylQHRpJJwGzZAvz61+LxffcBJ58sVv997z0RTgKEuNmxw1n7jPgx2HiF01lIfuXA5DIDCfDegTEb/NVE3mwFTHm5bo97PXgWegjJqogdELyAyXT+FJID41cIqaJC7+fCGkaigPEQt0NIxo7FeKeUScAcOiRyEi67DLjiCv31igrgv/9b5C4A+mCULdOnixyIDz7I7X2CIF8dGK/rwKg1YCRuODCxmH+DJ5N4xTadgPGjoKAZLGTnfxJvPK5fzxQwBYjXayEVF6d2NpmSeAFgwgTg/vu7TpME3LuzXLJEXAT19bm9TxCELQfG7RCSnw6MFDDbt3dthxP8qsZb6NOow5wDwxCS/9OooyBgWMjOQ7xeCwkQnbuVwJHU1go7v7wc+MtfrDsBt2L7n30mtrk6OUHgdBaSXyGksCfxqjVgJDKE9OmnXdvhBDow/hBmAcMk3vQOjJshJFUshl3AOHJgHnzwQXzjG99AZWUlKisrUVdXh1deeSX5+qFDhzB9+nT06dMHFRUVmDJlCnbu3JnyHlu3bsXkyZPRvXt39OvXD9deey06DEd96dKlGDt2LOLxOIYNG4Z58+Zl/x8GiDF3xe21kIDUgS1dIbt//hPYtAkYMMD6c9zopFpa9EE3rCd9OsLmwLg1C8nrDj6dAyMFLRBuAcMcGLENYxIvp1H7v5hj3gmYgQMH4s4770R9fT3eeustnH766fj+97+PjRs3AgBmzpyJF198Ec888wyWLVuG7du347zzzkv+fWdnJyZPnoy2tjasXLkSjz/+OObNm4ebb745uc+WLVswefJknHbaaVi3bh1mzJiByy67DAsXLnTpX/YPozMiBUx7u7OZPpkcGEk616Cy0rxjUnHDgVEHq7Ce9OnI9xwYr0NIag6M0YEpKcmuGJ8fg6em0YGx48Ds3x/MlFquheT/Yo5REDCOQkjnnHNOyu+33347HnzwQaxevRoDBw7Eo48+iieffBKnn346AOCxxx7DyJEjsXr1akyYMAGvvvoqNm3ahNdeew01NTU47rjjcNttt+H666/HLbfcgrKyMsydOxdDhw7FPffcAwAYOXIkVqxYgdmzZ2PSpEku/dv+YBVCAoSIMTsR072P2aBqV8DYwY2BQs13CEsIqbMTeOopMetqyJD0+4a1Em9UknjTOTDZuC+APwLmwAH97pU5MF1fU/uZlpbMIs9NEgn9uynkJF6/ZyF166YLmD17cn9fL8g6ibezsxPz58/H/v37UVdXh/r6erS3t2PixInJfUaMGIHBgwdj1apVAIBVq1Zh9OjRqFEmmE+aNAnNzc1JF2fVqlUp7yH3ke9hRWtrK5qbm1N+gsYqiRdwdiecrmOxE0KyS746MK+8Alx4IXDVVen36+jI3FFK1Eq8XtbNcWsatddJvGY5MFLAyM4vzAJGCrDi4sxOpTojRy5amQ+k62ficf3787trVc9ZhpA4C0nFsYDZsGEDKioqEI/HccUVV+C5557DqFGj0NjYiLKyMlQbpHlNTQ0aGxsBAI2NjSniRb4uX0u3T3NzMw6mOTtnzZqFqqqq5M+gQYOc/muuYzWNGnCWyJsuB0Yd2LKZ4aHihjWuOjBhOekbGlK3VqjuhN0QkqZ5u0CiXyGk9euBUaOA557L7v3T1YExtsEpfggYNf/FbIaeihT6mqZ/P/lAukJ2QHB5MOp1mSmE1N4e3qqxueJ3Ibt4HOjdWzwOS19uxLGAGT58ONatW4c1a9bgyiuvxMUXX4xNmzZ50TZH3HDDDWhqakr+bNu2LdD2tLfralgOhsXFutXnRMD47cDk0kGpDkxYQkgyB+PTT9O7JWpHaTeEBHgbRvKrEu8LL4iChjNnZtcJpgshScIsYOxOoQbE/yEHkXzKg0lXyA4ITsDIATUWMx+8gdS+L1/zYPwOIeWlA1NWVoZhw4bh+OOPx6xZs3Dsscfi3nvvRW1tLdra2rDXMGrt3LkTtV+tClVbW9tlVpL8PdM+lZWVKE8zQsfj8eTsKPkTJKpZpHYITmcimQkhFTdzYPI1hCQFzMGD6dskv7OysszJpiUl+nfpZSKvXw6M/B8++QR48UXn72+WxFtVpd8Zqm1wip8Cxk5uRyyWn8sJpLtRAvRz0G/XSR1Qrdwx9YYjXwUMC9l1JedCdolEAq2trTj++ONRWlqKxYsXJ19raGjA1q1bUVdXBwCoq6vDhg0bsGvXruQ+ixYtQmVlJUaNGpXcR30PuY98j6ggO4NYLLXjdlrMTh0cc5mFZId8TeJVzTi1JokRuwm8Ej9mIvm1mKPqIt13n/P3N8uBicVSXZhsBYw8x8MiYAD3E3l/+1tRZDLIayaTgJHXhd95JplmIAHCgZDORD7mwSQSujPKQnY6jgTMDTfcgOXLl+Pjjz/Ghg0bcMMNN2Dp0qWYOnUqqqqqMG3aNFxzzTV4/fXXUV9fj0suuQR1dXWYMGECAODMM8/EqFGjcOGFF+Kdd97BwoULceONN2L69OmIf3V2XnHFFfjoo49w3XXX4f3338cDDzyAp59+GjNnznT/v/cQNYFXvWtwWsxOvo9RCEnCnMS7d284khxV0ZJOwNidQi3xYyaSXyEkVYS9/jrw7rv23zvdFGRVwGSbo+VHGXu7NWAkbk+l/uMfgTVrxAKrQZEpByaoRNlMRewk+ZzIK8NHAAvZqTgSMLt27cJFF12E4cOH44wzzsCbb76JhQsX4tvf/jYAYPbs2fjud7+LKVOm4JRTTkFtbS2effbZ5N8XFxdjwYIFKC4uRl1dHS644AJcdNFFuPXWW5P7DB06FC+99BIWLVqEY489Fvfccw8eeeSRyE+hljgNIanvY2afepHEm+1dZSKRuhCkptl/r0QCuOgi4IYbsvtsKzo6UtvkpgOjzkTyCrcXc+zoML9LkyJMdoS//73991anIBsFgJrIG4UQkp0cGHU/t9okj/+WLe68Xy5tsHJgghYwmc6ffK4FowoYLwvZqVPWVQHT1BTO5GhHdWAeffTRtK9369YNc+bMwZw5cyz3GTJkCF5++eW073Pqqadi7dq1TpoWOqzu5rMNIVm5AvLOvLRUH3yyJVcH5vPPxckvk+3a2sTAYOeu9v33gf/9X/H45ptzd5MkjY2pLpAXDoxXAkad5eJWCAkQA4JxkJL/w09+AjzxhPguZs3SZyGkQw7+JSVd797dCCGFLQcGcN+BkeLho4/ceb9syBRCCkrA2AkhAfntwKjjhZeF7IxT1tW+sKnJXn/gJ1zM0SOsOgOnIaRMnYq8M3djwM91oJD5LzU1YjVqwL71+M9/mj/OFeNktCjlwMjVwwH3QkiAufsnB9CzzwaOPVYMAn/8o733VvNfjC5hVBwYpyGkdA5MNnfBYXBgwipgGEJKdWDMblTdcmDUvqFbN3EjKm9KwhhGooDxCKvaLU5DSOlqwADuChjZKR84kHrB2EXmvwwY4Dx2+uGH+uMPPnD+2VYYBYubDozXCzqqsz2svn+7lJTo4iKdgOnRA/jFL8Tj+++3d0eXzr0oNAdm4UIhNu+4w/5nJxK6eI6CA+N3iMbtENLmzcCcOd7Wb3IbdQq1WSqBWzkw6jGRoaow58FQwHiEVegn2xCSVafSr5/YSscjF9SZ59kkTEoH5vDD9YHA7qwKVcBkKjjnBClYzFZGNhI2B0Z+Bz16ZLeGkEoslr6DV8+zn/5UWMV2p1T7JWBaW70bdGS14FwdmOefF2288UYhZuygnj8ffxxM4ntnp35sw5bE63YI6ZprRFXuDJkMoSLdFGrA/RCSOmWdAqYAcTuEZOUKjB4NzJ0LPPKI8zYaKS3VPyeb2H4uDowaNvLCgZGz8KOUA+NW/osk3VRq1YEpLwd+/nPxu50p1WY1YCRuhJCM6/B4weefi628IciElQMjZ29pGnDBBamz8qxQHby2ttRSBH6RqVwDEP4Qkl0HRt4gKdU8Qk+6InaA+yEk9VqlgClAMiXxuhVCisWAf/1XfYDOlVwSeWVnrTowQYeQZA7M+PFi29JiHYrIdhaS1yGkXGcgSdIt6GgU3FdeKVyf11/PnJdhVgNG4oYDo65P5FUYSQ5mxuUPrDBzYDQN+GpJN/TvD+zeLdysTIOK8fwJIg9GFTBW539QdWDshpDsCKxEAti6VTz2eiFWN0m3jADgfgiJAqbAyTSN2q0Qktvkkm+ghpDkSW8nhNTRIaxziRcOzPDhepusXJh8d2DSLeioOjAAMHgwMGaMeJxpQmC6EJIbDgzgbR6MpukOjF0BY+bA7NghOvniYuDVV8X3tnw5cMst6d/LeP4EkQeTqVwDkB8hpM8/189/L8sfSPbuFctz1Nfn9j6ZxgE6MMRVrAZDt2chuY0dB8ZqPaFsQ0hbt4oLT95dfPGF+HEDKVYGDQIGDkx9zkjYcmD8DCGZnWdHHy220lWwwuscGEB3obwIITU16RZ9Lg6MDB8ddRRwzDHAww+L3++4I30+TJgcmHQrcedDCOmTT/THfjgwzz4L/M//AP/1X7m9j/EGw4hbOTBmYpECpgBxu5CdW3VRMpHpTveKK4SbYeasZJvEK8NHw4YJoQG448J0duptGjhQFzBW63zKjjlsISS3HRhjB9/erg/gagf51eoeyLRWa7ocGDcq8QLeOjDSfamosH+dmTkwUsAcc4zY/uQn4nrRNODCC62FrvH8CcKByVTEDvBOwGgacOmlet6VETdDSH4LGDnoq8U0jezdC5x2GvCHP1jvk0nA+BFCkonuYYICxiPcCiFlyoFxm0wOzDPPiGmIS5emPt/aKmL+gHMHRgqYr30N+PrXxWM3BExjoxAxxcWiNo1dByZfQ0hWDozakasdpBsOTDyuuydhDSE5DR8B5teJPE7yuAHA7NniuHz+uXV9ozA5MEEImIYG4LHHhGNltlCk3RCSHQdG5r8A/oSQ5HcrzzEzXn9d9Kdz52Z+n0wODENIxBWiGkJKN1B0dOgnsTGmK+8w4nExBdfJSS87drcFjBQqAwYIEZNJwDh1YPyaRu21gJHtVxfEA/SBuKEhfceYLokX0F2YsAoYmcBrdwYSkD6EJB0YQJxLssSB1SrOcnCS33PQOTBWeFUHZuVK/bGZK+JmITu/HRg7Akaef+lW+fYrhGR2rClgCpCohpDSOTB79uj5L2+9lfqamv8Si2UfQvJCwMiwlNsOjN0QUmenqKfiNH/DrxCS2jmqCZxDhojzt60tfXXkTEXgpLMRVgGTjQMj23PokDg+iYTuwKgCBtC/P6sBSl7jUjBu3+5/sbggHZhVq/TH6QRMFENI8jNaWqz7fDcEjJchJLl8AAVMAeH2Wkh+h5DMBgoZIgKEA6Mm86r5L0DuISQ3itlJoSKFS1AOzMMPA9/7nvOFKr2aRm3lwBjPsaIiPQ8mXRgpXQ4MIKYUA7n9H34IGCcOjFr0sblZDIz794vre9iw1H0zCRg5OA0erO+rzsrzg0wDJOCdgMnkwLgZQlIFjB8hJPU7V/tPFXn+pRNUDCGZQwHjEW4VsvM7BybdInXqBfj556lCQHVggNST3mrWEiBeUwXM8OHi8ebNuVcklcm6dgWMVzkwS5aI7Wuv2XtfiVc5MOkcGCN28mAyOTA33QTMmAGce669dprhRwjJiQOj1qZpatKPz4gR+mAisStgevQAjjxSPPY7D8bOjZIXdWC+/DI1SdzrEJKaA+OnAwNYh5Hk+bd/v3Vf6XcIiQKmwHE7hBSGJF7jBajmwahF7AB9MGtrS39H1Ngo/seiIuCII0TYorRU/E26qrl2sHJg9u41H0yynYWUScC88YbYNjQ4y+T3qw5MuhkomQRMIpFZwBx/vJ7Mmi1hCyEBqW6lWf6LxImAGTpUPPY7DyaoENLq1am/5xJCyuTAtLSkDsJhETDyeXVNLKv3CXIWUlNT7gLJbShgPMLtEFIYplEbLVBVwMgQknRgevbU1+9Jp9yl+zJ4sDg2JSXCiQFyz4Mx5sBUVuphDLMS79k6MOk6wp07U21rY4edDr9mIaWrAZJJwLS06HeNuQiUTIQtiRdIdSvTCRh5XDPlwKgOTKEIGDV8BOQ2CylT+9TrEPB3FhKQ2YEx7q+SqU6PHyEkILsK7V5CAeMRbq+FFAYHRgoYOVNFTeQ1OjBqIm86AaPOQJK4lQdjdGAAXcyYuTteFLJ7883U350IGLdnIdlJ4jUiBcwHH5ivUC7dl27dcqvzkgkpPMPuwKhTqCVRCiH5nQNjFDBehpBk+Ej2X2FzYIz7m71PEIXsSkv1zw1bGIkCxiP8WgvJbdLd6coL7aSTxFZN5DU6MIC95QTUGUgSmQeTiwPT2amLKlXApMuD8WIpASlg5HuqMy7S0dCgO1xOB1YrnCbxAkLw9eghxIvZTKRM4SO3kOelF5V4s0niBfQ27dkDvP++eJxLCKl79+BCSE4K2bW2urNidkcHsGaNeHzEEantUHErhCQdmKOOsv4st1E/wyyJN5FIfd6OyDXDyxASEN48GAoYj4jqWkh2HJgzzhAXjEzk1bSuDgxg76RXE3glbkyl3rVLXMxFRUBtrf58OgGT7WKOBw5Yd+gy/+XCC8V2zZrMd0n79wNTpojO7F/+BTj5ZHvtyUQ2SbyZZiJlqgHjFrmEkBIJ6+8nm3WQJPJaeftt0fF3764PxCrZOjDpkt/dxkkICbB/A5aOd98V/3tlJXDCCeK5XGYh2Q0hyfM5XdKsW2RyYL78MrU/yNWBoYAhrmDlnGQbQgoiB8Z4ccsLcNAg3Sqvrxf7ynaqDoydWjDpQki5CBi1iJ06K8QLBwYwv+vTNF3AXHqpGMhaWtKX5tc0sRL0xo1CeM2f33VWS7ZYJfFmGrzS5cH47cBkI2D+9V9FB2z2nWezDpKxTf/4h9gefbSe96Vitw5Mjx66AGpu9rd0u1MB40YYSYaPxo/Xj2UuISS7DszIkWKbSNjvh7NF/c7NBIya/wIEH0KigCEArIVHVGYhdXR07aSkA9O3r5hZAggBI92X6urUdjpxYNQQkhQwH3+c/Z2eWf6L+rsbDoz63ZqFkT76SAxCZWViZWd5l5kuD+bhh4H//V/hcP3f/6W6R7mSaSkBq87RjoCxqgHjFtkKmM8+A/74R/F3y5d3fV0OID17Os/hkdfKO++IrVn+C+DMgSkv1+vm+JkHYycHpqREHyjdFDDf+lb6opBuOTAyB0YKGKvPc5NMDozxubCEkIzXAgVMAaFp0V0LqaJCr8ZqHCykgDnsMF3AvPVW1yJ2kkwn/Zdf6neZ0joHxLpFPXuKOyQpcJxirAEjcdOBKS7WL3SzjlC6L8cdJ773CRPE71Z5MPX1wC9+IR7fcQdwyin22mGXTCGkKDgwLS3O8i/+3//T9zfOQgGyDx8BuoCRd71m+S+ALmDs3l0HkQdjJwcGcLcWjF0B41YlXvn9f+1r/iTydnSk9vNuODBW3w9DSMQ12tr08EsuayF1duonlF8CJhazLmYnL8C+fYFx48Rj1YFRw0dA5hCSFCc1NakzbWKx3BN5/XBggPSJvFLASOelrk5szQTM3r3AD38ozovvfx+49lr7bbBLphBSJgfmgw+6nrd+58AA6Uuuq2iacF8kbgsYtU1AZgFjJ4kXCGYmkl2n162ZSDt2iP8vFhMhJDsCJpcQUlubfqM1ZIj9Gk65YPxfzJJ4jaKGISRnUMB4gHpR5FLITu0k/MqBAcyXEzhwQG9P377AN76hJ/LKmQROHRiz8JHESR6MWb6OsQaMRAqY3btTO7rOTn1wdkvAyBlIUsBIB+b997sek9/9ToTMhg4F5s1LXZPILbINIQ0aJByxjg5RIVnFLwcmHtfvmu2Gkf7xj9SZU2oVVkm2NWAA/TqRZCtgjALSawdm/Xpg2jTgz3/W3Sm/BYwU8cccI46j1yGkzz4TfUS3buK7truOWS4Y3/uLL7oKDKMDk20IyS8Hxs+8LDtQwHiAvICMq/sCzkJI6qDop4Axc2Dk3UM8Ljrk8nL9zvzFF8XWyoGxEjBmCbwSuwLmgQfExXXrranPWzkwap6OWsxOHdSdHGurjrC9XcxOAXQB07evPoVTij5AdFr33y8e//d/eycGrO5QMw1esZg+c8OYgOxXDozqDNoVMI89JrYyMdZLB6aqquv5L3GSAwN468A88YQQ0n/8I/CjH4lQ8IIF9kNIbgkYNXwEuBtC6uzsWrNIfveDB4tzyU4RylyR7y3bpWldBYAdB0bT/MuBsRKLdGAKiHQDgpMQklra3mx2g1eYTaVWw0fSHZB5MFIsWDkwmUJI6QRMumJ2r7wickYSCeC3v039HKscmFhMf07uA6R2yG44MBs3ivesqtJFC2CeB/PII6JjGDYMOO88+5/tlGwdGMA6D8YvBwZwJmD27weeflo8vvFGsf3kE+uZdbk6MMccY+2aORUwXjgw7e3A1VcDF1wgzstvflO4auvWAeecoztr6c4BQB+Mc10tW57/TgSM3RCSWftUAaN+nh8hpOpqvS80ChbpwEgBYvb/t7Xpzk3QDgwFTAGQTsA4CSH5PQNJYjZQqDOQJDIPRmK8A80lhJQpB+bdd4Ef/1iIl+JiMTjMnSteSyTMi9hJzPJgZIenzrSwg5WAkfkv48alik+ZByNnIrW3i/ARAPzqV3pH5gXZJvEC1rVg5B2lHwLGSTXeP/9ZnBPDhgE//al4bv/+rnfA2SzkKFEdGKvwEZBewKiJnsYcmE8+cWftmcZGUbvpvvvE7zfeKATEli3A9denOo6Zqj674cC0tupVvOX14EYISRUwxvZJATNkSObPcwv5fffooZ9fRgEjf5fCyqw96nPMgUmFAsYD0s1mySaE5Gf4CEjvwKgdvXRgJEYHJpcQknQtdu3q6uDs3Al897tiRsqppwJ/+IN4/t57xQX4+edCGBQV6VNSVcwEjNOFHCVWHaExgVciO+w1a4TQeuop4QTV1AAXX+zss52SbRIvYO7AvPACsGKFeGz2HbqNk2q8Mnz0s5+J66emRvxuDCO5MQsJsCdg2tq6Xvdmg9OAASL03NGR+4Km770n3Ja//10cv+efB267TQjlPn2AO+8UTs+11wo3U3ULzXBDwLz9tjgOffvqNy9W60V1duqDciYBE4tZi3SZ/yQFTDYhpL/+VQ+X20F11uT5ZUzklQJaum5mIle+T2lp15QEiV+VeLkWUgHgVggpKAfGLInXzIGRibwSKwfGLIR08KA+K8Bs8OvZUxcfauLowYPAueeKgeioo4C//EVUuT38cHGn+ac/6Z1+ba35BZ/OgXEqFq0cGGMCr+SYY0SH1tQk8knuuks8f/XV3q4lBLgTQtq8WZy7778vwhEAMH06MHasu201w24I6cMPgWXLxIB20UXiOXmHaxQwuSTxqg6MVQ0YIPW4GgdMed4UFenfT3GxnreTSx7M22+LqfiffgqMGCFE9fe/33W/2lpxHt53X+bkcTemUav5L/LzrG4E1HPVzvVhJbBydWD27RM5Q9/7ni6OM6FeV7LftHJgpIBJ58BkqtEDeCdg5JiQrihpEFDAOOSOO4DTThN3dv/5nyIZbvHiVOVsx4FxMgspqBCSWRKvKmDURN6iIv0uVyIFTEtL1wtLxverqsSdoBkyD+b++4Hf/EbMnDj5ZBF+6dVLJB/27i2O6cyZYt/f/la/2zILH6nPqwJGdhJORYSZgNm/X1/czyhgSkrEHTEA3HSTcDR69hTVd70m2yReQByzykrxPb71lhCRLS1igJw925PmdsEoYP75TxEeOuUU4Pe/152+efPE9tvf1mehyYHLOBMpFwemVy9x3sdi6R2YsjL9ujfeYauDkyoecs2D+fvfRT+1e7cIY65YoYdlc8ENB0a6eKqDayUo1HM1kwOTrn255sDs2aMnBl9+uci/y4SZA6MKmM5OvV91S8C4FUIy9oPSTW9q8neJi0y4VKS8cHjzTWDp0q7PH364uLMYPNheDowdB8aYxe4XZg6MVUd//PFiWmZNTdfcEdVi37s3Vfyo4SOru74RI8Sd9P/7f6nPl5QI50UKHEB0KrfeKpwBmQtjV8Ds26cLIDnQ2UV2Kmpuxdtvi/DQ4Yebz0ypqxPn0PPPi9//9V/9ySHJxYGRM5FWrxb1anbsEMfxmWesbW23kQLm00+B664D/ud/9EHl738Xz/3wh8Drr4vnLrlE/1v5vaoOTC7rIAHiupTnWqa/r6gQ54iVgDH2FbnMRHrlFZEMfuiQWEvrhRe61qzJFjcEjOxX1BuXTA5MLGYvN81MpGta7iEktS/s7BTn2dKl+s2IGZkEzJ49uhiQwipdCCnd9el1CEn2T52doj2ZcqX8ggLGITffLE7eTz7Rf9auFUmj55wj7nTSOSdOQkhylozV9EyvsOvAAOLu7rHHuua/AGJgq6gQF6VRwKSbgST5xS9EWCgeFwJJ/px8cte7ycpK4IorhBX+6qviOWMNGIl8/tNPRUd37rkiqbFXL2DOHOv2mCH/pzvuEML11lv1/Berzk3ORALEMZoxw9lnZotVfoDdUOXRRwsBs2OHGCiefz670Eu2yPPyt7/Vn5s0CTjzTODxx4WQ/tOfxPPV1eJ7lZgJmL179Q4/2xW/L7/c3n6ZBIxxcMrGgVm/Xoj9++4Twm7yZCEw3bwBckPAyBwmmZQN6AOiXBhVJr6rjoCd2ki9ewvR9847+nW2a5d4H3UGotMQkmzzoEFiKYJXXxXHd+VK80kI6ntbCRgZvuzdW7/ZC2sIqbxc9FXt7eK6oYCJKGPGiB+VrVtFqGD9emFpn322eD5dCCmRECdbursK6VJYXSBeYTcHBhBx4aefFosVmlFdLTptYyJvuhlIkqOP1l0KO1x9tQhnyLvyTA7Mzp2i/YsXi87hlVdEXo8TrrtOFKB76ikxm+jZZ0WHBHQNH0lUASPzd/zALIlXrfacaQqtmufx0ENdk7i9RnX0vv51cby/8x0xMM2cKdzRhx8GXnoJ+Pd/T7XBzQSMHEyyWQfJKVYzkawSqKUDs2SJKMh34onm77tjB/Dkk0K4rF+vP/+Tn4jn3HbHvBIw6v9/8KD+u90ZSJILLhDVwWfPFuKyqEj/zmVytPp5dkNIqmv05z+LyQNvvw2cdZYQMWZCXgqPigpzAaNO4U+33EQQISTj8Y7FRF/++edCwFj1rX7DHBgXGDxY2LTduom8jFmzxPPpQkhAZhdGJq9mmhngNmYOjJXVfthhwkqVyZJGrBJ533tPbN383wYM0BNLAeuLrE8f/QJdsEA8fvFFUdLcKdXVYgB56SVxHnz8cdcCdkb69RNhpB49hADyCzWEJK1rtcPM5MCce674vm69VQgvv/nhD8V04HvuATZsEHfA8q48FhPH++GHRXL4v/976t+aCZhcEnidYiVgrAanM84Q529jI3DSSSJHSl6PmiZCZj/+sTjnfvUrIV5KS4Ef/AB47jlRsM6L0J4bdWCkGFAFjHqzp56TdovYSaZNE0K3oUFck0DXBF4g+xBSz57i56WXhEv24YcilGmG2TRqdRaS2qdazcJS2+hHCCmdYMy0NEwQUMC4xAkn6LkaMrfCzIFRT4xMAiZoB8ZOCCkTZvUDNE1fwffYY7NroxW/+pX+2ErAqFZySYm4ozrttNw+9zvfEcmJM2aIu74ePbrWyVFZuFAIVDcSK+0izz3p/gH6HWgsltmFGDpU1OW56Sbv2piOESOA114Drrkm9UbADjLHYPdu/X/OJf/FKU4FTK9e4hqZNk38PneuyEH6r/8SDvAppwjns6NDiOEHHxRi59lnhdD0qvClVw5MUZG5qLBbxE7Ss6fIKQP0UKMx/wXIPoQkb+5qa/XEe6up7plmIakCOl17whBCAihg8p4f/Uh0MBKzO1o1ZJRuJlJ7u7ibB/wXMMbZHomEWMcDcC5gzGrBfPaZyAcoLtYLpLnFqFGiUNd3v2vtgAAij6a0VIjO737Xnc+uqBDW9aZNos6Lca0cFXWauF+og4A896xmweQb1dX6gCkHtDAJGLO+ondvUaX59deF87V9uxCP77wjhMTll4vHK1eK/C8ZuvQSNwWMMbHYbBB3GkICgF/+UvSzy5eLsKKZA5NtCMm4fARgXRvFKgdGup/q+ReGEJJ6Y0MBU6D85jd6OEWdJSOJxezNRPrkE3EylZf7n8RrvDC//FJf9C1bB0Y96aX7Mny4N7kHt90mQkLp7tIffVTkwJx/vvufP3x4+rogQaF2SlLABFVryG9isa5hpDCEkOwUETz1VHHN3HijSAz/7W/FXf9DDznP2cqVXOvAaJq5AwOYCxinISRA5JTJ6/qee7pOobb6rHSYhb2yETDt7fp7mTkwBw92FSF+hZDUG2oKmAIlFhN1KN59F/i3fzPfx85MJHWasZ/rIAH6hblvX2qtgqoq53F1sxCSV+EjJxQVeb8AYdgoLtbv1OSdrZ3OMV8wCpgwOTB21iC67TYxw+3f/90ft8WqHUD2Aqa1VR9knQgYpzc6MgfqmWf0opK55MCYuUZOBEx5uf7/yfPOLAcG6OoKOXVgsq3TkknAhLGYHQWMB8Ri4g7cSnjYKWYnE3j9Dh8BqRdpS0vqQo5OMQshhUHAFCrGWjCF4sAA0RYwYSFXAaMuA2GciutWCAkQfcu3vy2c4x07xHNuh5DMJjuoGL9bYyKv6sCUl+shXKOociJgAN0td4o6Hpm513RgCAB7ISTpwPg9AwkQnYXsMJqb9Qsu22qlgHkIiQLGf4y1YKI2gOaCDCHIHJgwhJDsLKQZJnIVMFIIdO/edeFSt0JIEuNMNK9CSFZLW6jTqIGuibyqgI7FrGci2Qkzqscy2zCSeqzN8uHUarxhgQImAJyEkIJwYIDUu4tsZyABXR2YAwd0d4kCxn+MtWCiNoDmQhgdGDuDU5hwy4Exho8A8wE82xASIAocyiUeevVK/Uy3Q0hmYRt1GjXQtRaMUUBbiSqnDowqYNauFTlU//iH9d9KMolFOjAEgLMQUhAODJB6d5HrejGALmA2bhQW52GHiamIxF+sQkhRGUBzIYxJvFFzwHKtA2M1AwlwN4QECBdBllUYOTLzZ6Uj3Sykjg5zQWcVQvr8c/E3cvkR+bzVTCSnAkZNAn7qKbEcy/33W/+tJIoChpV4AyBTCKmjQ18DJeoOjDGEpIaP8nnablgxrhUTtQE0F6SA+ewzMRskl9CoU/JNwHjpwLiRxCu56CIRXjGulq7mwGha5r7ILIRUUSHyHBMJ0U8aXcx0AuaLL/TPlWtCWYWQcnFgpEiqr7f+W0kmsRhGAUMHJgCsFtWTyCnU3br5V2beiJkD40YIifkvwVLISby1tWIWXWencAJzXQfJCRQwgmwFTDYODCAEwgUXdK03Jc/3RCK9Ey4xc45isfSJvOkEjOxT+/TR81cyhZDSXaPqhBFVwMh+d/PmzLkrUXRgKGACIJMDE+QUaoka33UridfLCrzEHoWcxFtUpC/k+dZbYltZmf3g6IR8SeLNtQ5MOgFjFkLJJYSUDvV8txNGMgshAdZTqTs69P5dfpa8Ady92zx8mUsIKRbThZAaQlJnf8olTqyggCG2sCtgggofAe6HkDo7ReclF5yjgAmGQk7iBfQwkhQwfrgvAJN4JWahGIkXISQrSkr0ftjOVGqrdlsJGPV/SOfAqOdfLiEkwHw5ARlCAvRz3opMAkatA5NtrRm3oYAJgEwhpKATeAH3QkhyGXZAuC9NTeL3ESPcaSdxRiEn8QJdBYwfCbxA/oWQ2tqyK1vvNIk31xBSOuzORGpt1W82je02Lrsike9ZXKy3XRUwZg5MLrOQ5GcB5iEkIHMejF0HpqPDfv0cr6GACYCoOjDZ3K3GYroLs3Sp2I4a5XwxPuIOViGkQnNgpBMYtAMTVQEDZDcTyWkOjFchJKvPM0MtvmfXgVGnUMsE4UwOTC4hJMA9B8bK7erRQxdJYakFQwETAJkETJBVeCXywty1S78Ys3FgAF25L1smtn6v30J0jCGkQnVg2tvF1m8Bc+BAqnMRNQHpt4DxKoSkfl4mNyFd8b1MIST1upLn2v79+lR+MwdGFbmdnfoxsCtg5PnV3p76Xh9+mOrIGMnkwMRi4cuDoYAJgHQhJHUKdZAhJOnAfPih2JaUpF9dOR3SgVm5UmyZ/xIcxnMvag5Arqjl5AH/Q0hA6oAZNQFZXKyHhLPJg/F7FlI67IaQ0oW9nAiYykr92L33ntia5cCo7THLpbHCGEJSxYqsQpwukdfOsaaAIWkdmG3bhHKOx4GBA/1tl4q8MD/6SGz79s2+bosUMLLDo4AJDmMdmEKaRg2klpMH/HNgunXTZxTKu+K2Nn2wiYqAAXJL5I1iCMlqBhLgTMDEYrqLvWmT2GaahSQfx2KZXShjCEkKmKoq4IQTxON0eTAUMMQW6QSMDB8deWRwU6gB/WKVF0G24SNAP+klFDDBUegOjJxGLfFLwMRiXfNgnNxdh4lcBExYZiGpn2c3hGTWZicCBkgNI6m/q/uaCRg1l8YKYwhJ9t29egHjxonH6fJg7IhFChiSNoQU5CKOKsZwUS4CRjowANC/v3+DBulKoSfxxuPiHJT4FUICrAVMSYkeWogCudSCCdMsJKdJvLk6MEDXvi9TDoyTGwxjCEkm8PbuDRx/vHhMB4bkjB0HJsgEXqCrgMlFdKgChu5LsBR6Ei+Qmgfjp5g2CpioHnuvQ0jqAO5lCMluDky6EJLVNGr5P6i5T0DX8y3TLCQnAsYqhNSrly5gPvoodWaSCgUMsUW61ajD4sAYL1a3QkgUMMFS6CEkIFXAhMGBidqx91rAyPWJAH9CSHYFjJshJECkCPTunb492QgYGUJSHZhevURaAmCdyGtHwKjF7MIABUwApFuNOgw1YADvQkgUMMFS6Em8QGoiby7ntVMoYOwJGE3T39uPEFKmHBg3Q0jq+da3b2qeo9shJNWBATLnwdCBIbawCiF1duqzfoIWMJmsTyfQgQkPqgOTSOgDRdQG0VyQDoxf6yBJ8k3AOK0D09mpiwUzAaOKaHlswh5CysWBMfapXoaQAF3AWOXB2HG7ZF/OQnYFjFUIads28VxZWdfZEn5TXJzaybjhwMTjwNe/nlu7SG6oSbzqHXQhOTBHHCG2foaPAOscmKgd+2wdmHQVbQHR58j3lgN3PoeQjOeflyEkQM+DyScHpiToBhQiViEkdQq1seJjEFRW6p1OLgLm2GPFsvFnnqlfZCQY1CRetaNUK6zmO6efDpx3HjB5sr+fm28OTLYCprTUepDs0UO8r1HAhD2E1NoqfmQ7s3FgvA4hjR0rth9/DHzxheiTVaIoYBw5MLNmzcI3v/lN9OzZE/369cO5556LhoaGlH0OHTqE6dOno0+fPqioqMCUKVOwc+fOlH22bt2KyZMno3v37ujXrx+uvfZadKgLOABYunQpxo4di3g8jmHDhmHevHnZ/YchxCqEFJYEXomaB5NLCKlvX2DHDuCJJ3JvE8kNNYQkO8fy8mBrDvlNeTnwl78Al17q7+dSwIhtz57WNU2MLkTYQ0iqK6O6MNk4MPL86OjQx4ZcQkhGB6a6Wk9NMAsj5X0dmGXLlmH69OlYvXo1Fi1ahPb2dpx55pnYr5wBM2fOxIsvvohnnnkGy5Ytw/bt23HeeeclX+/s7MTkyZPR1taGlStX4vHHH8e8efNw8803J/fZsmULJk+ejNNOOw3r1q3DjBkzcNlll2HhwoUu/MvBYxVCCksCr0QVMLkmO5aWZl/Jl7iHGkKK6jTeqJIvAibbOjDpEnglRgET9hBScbH+vapTqa2mUav9qJUDo7YplxCS0YEB0ufBRNGBcWTo/+1vf0v5fd68eejXrx/q6+txyimnoKmpCY8++iiefPJJnH766QCAxx57DCNHjsTq1asxYcIEvPrqq9i0aRNee+011NTU4LjjjsNtt92G66+/HrfccgvKysowd+5cDB06FPfccw8AYOTIkVixYgVmz56NSZMmufSvB0emEFJYBIx6x+HnbA3iHWYhpKgNoFHFSsAUWg5MNgImrCEkQNzo7dtnz4Hp00fcyGlaVwemtFT8yEUYe/VyN4QEiDyY+fPN82CcChhNC/6mNCfjuOmrb6z3Vx5VfX092tvbMXHixOQ+I0aMwODBg7Fq1SoAwKpVqzB69GjU1NQk95k0aRKam5uxcePG5D7qe8h95HuY0draiubm5pSfsBK1EFJFhTd3QMR/1BBSVJNIo0qhF7JL52RIVAHT0aG7CWENIQHmibxWwqO4WA/pmIXljQLOyTmSKYQEuOfAtLVltxq522QtYBKJBGbMmIETTzwRxxxzDACgsbERZWVlqDYsflNTU4PGxsbkPqp4ka/L19Lt09zcjIMWV82sWbNQVVWV/BkU9DSeNJiFkDRNX4VaFhwKGnnB0n3JH9Q6MHRg/MWYpBnV45/tNOpMTgaQOoCrDnVYQ0iAMwEDAEOHiq1ZP2+cSp1tCOngQf34qQ6MTOT95BORyKtiR8BUVOj5cmEII2UtYKZPn453330X8+fPd7M9WXPDDTegqakp+bNt27agm2SJWQhp507RIRQVBT+FWiIvTK5dlD+YJfHSgfGHfMmB8SuEpPaPQYWQNM1eCAmwL2D+93+BZ54BxoyxblM254jqwEj3xVgOo7JSD11t357693YETCxmPXU8CLKa1HrVVVdhwYIFWL58OQYOHJh8vra2Fm1tbdi7d2+KC7Nz507U1tYm93njjTdS3k/OUlL3Mc5c2rlzJyorK1FuMd8zHo8j7mdVqhwwCyFJ9+Xww/XXg4YOTP7BJN7goIARWzsCZt8+3eEpKvKm/IIdB+bgQT2M5ZaAGTFC/Nhpk5ObDDUHRs1/Meap9O0L7NoF7N6d+rzdhOnqavH+kXNgNE3DVVddheeeew5LlizBUOmFfcXxxx+P0tJSLF68OPlcQ0MDtm7dirq6OgBAXV0dNmzYgF27diX3WbRoESorKzFq1KjkPup7yH3ke0QdsxCSFDCGQxooX/ua2LL4XP5glsRLB8YfWMhObJ06MF7l36k5MHLtJSMyfBSLWQtNpwImHW6FkKSAUfNfJPKG9PPPU5+3mzAdpplIjnTt9OnT8eSTT+Kvf/0revbsmcxZqaqqQnl5OaqqqjBt2jRcc8016N27NyorK/GLX/wCdXV1mDBhAgDgzDPPxKhRo3DhhRfirrvuQmNjI2688UZMnz496aBcccUVuP/++3Hdddfh0ksvxZIlS/D000/jpZdecvnfDwazENLHH4ttmATMj38M1NQA48cH3RLiFmZJvFFzAKIKHRixdSpgvDLW1bWXDh0yL+Zop3aNFDBS7LS36zenxmnUdtvkVghJzX+RSAFj5cDkrYB58MEHAQCnnnpqyvOPPfYYfvaznwEAZs+ejaKiIkyZMgWtra2YNGkSHnjggeS+xcXFWLBgAa688krU1dWhR48euPjii3Hrrbcm9xk6dCheeuklzJw5E/feey8GDhyIRx55JC+mUAPpQ0iyzHkYKCkBDJPBSMRRHRjZSUZtAI0q+SJgsq0D43QWkpdF7IBU5+vAAXMBk2kGkvqadGDUkJTT79YqhOR0GrXZFGqJlYCxe7wjK2A0K59NoVu3bpgzZw7mzJljuc+QIUPw8ssvp32fU089FWvXrnXSvMhgFkIKowND8g+1c5IdUNRCGFFFFTCaFl0Bk6sDk04MqCEUr0NIJSXiZrKtTXyesbQ+YE90GUNI8nstLnaez+hGCEl1YNKFkPLBgSmgAuLhwSyEFEYHhuQfauckO7moDaBRRQ5OiURqEnXUBKRfISSvHRjj55lhR3RZCZgePZwXenMjhKTmwOR7CIkCJgCMIaTOTmDrVvGYDgzxEjMBE7UBNKqog9C+fdF3YLKtAxOWHBj186ymUtsJIaUTMNm2RyYWO8lTMwsh2XVgEgm9AF6m4y3/XwqYAkWeIB0d4sTZvl0kfpWUiGnUhHhFLKYLaDow/lJcrA/++SBgoj4LCchcjTeXEFI236saQjp4UJ8d5XUSr5OaO3RgChw1LtrWpoePBg/WVTQhXiE7KDow/iMHqJYWChgz8i2ElG17VIEL2LtGcwkhZSNgwlDIjgImAIwChgm8xE/kHS0dGP+RAmb3bv3uOmoCMte1kJwuJRCVEJLc12olaift2b9fFzDdutm7sVVDSE6TeFUBkynxmA5MgWPlwFDAED+QA4K8S6OA8Q85qCl1PCN3/KWAaW/Xq9RmQi3Jn28hJClu5AKUboWQnL6PGkKy48AcPKgLN1UsZko8poApcNTS2K2tnIFE/EUOCHLwiZoDEGXkACVXSonHoxc2VgWFXRfm4EGR7wfkbwgJEILHrSTebAVMpkq8FRX6TbR0YZy4XRQwJGUmEkNIxE+MnVTUHIAoYxQwUTz2asE3uwJGCgEg/f8c1hBSOtFVWqofk6Ym93Ng7L6PFMLt7ekdmFisaxjJiVikgCEpxezowBA/MXZSdGD8Ix8ETFGRfgPmVMBUVIi/t0Iej0RCHyDDEEJK58AAqYm8QYeQvvxSd1fNBAwAHHaY2ObiwBw65HwqvdtQwASE7AD27QM+/VQ8pgND/MA4IERxEI0qxhyYqIpHq1owb70FXH99V0FgJ/8FSD0XZSJq2ENIgHsCxo0QklyksVs38+URgK4OjBMBo64LFfRMJAqYgJAC5sMPxd1Gt25AbW2wbSKFAUNIwZEPDgxgPRPpppuAu+4C/vzn1OftOhnFxV2n+QcpYOyEkAD3BUwuISQpYKzcFyA3AVNUpH+PQYeRKGACQp4oDQ1iO2SI87LThGSD0YGJqgsQRfJdwMiK4h9+mPq8XQcG0I/JF1+IrZchJDemUQOpAiaXadTybw4ccL7YqtGBMUvgleQiYIDw5MFQwASEdGCkgGH4iPgFc2CCI98FTGOj2H7ySerzTgSMPEZ+ODCZcmDshpDk627NQtI0XVxkK2C8cmCA8BSzo4AJCKOAYQIv8Qu1k4riNN4oIwdnOWBEVTyaCZjWVl105CJg5IAddAgpkbDfbrdCSOr5IPOknIaQ5Bp7dhwYKXbowBBHGENIdGCIX6iWfFQdgKhiDCtE9fjLc0gVMNJ9AfTSEJIohpBkCAfwL4m3qEgXMU4FjHRgJNk4MHaPNQVMgSMdGHlhU8AQv1DvsqLqAESVfBEwZg7Mjh36408/1Vc3BuyHYgD9mMjwRFAhJNnmkpLMA7tbAkb9uyAEDB0YYgvjehMMIRG/UDupqA6gUSXfBIw6jVp1YDo7ge3b9d/tzuYBuh6ToEJIapszTbAIo4BxksTrtOoxBUyBYzxR6MAQv2AIKTiMAiaqDlgmBwZIzYPJJoQkCSqEZHcGEuCugMm2VpAxl82uA6NpdGCIQ1QHpqIC6NMnuLaQwoIhpODINwfGDwETdAjJqYDJZRo10DWE5oUDI8ebjg4h1JwKGPn/UsAUKKqAOeII1oAh/kEHJjgKScCoibxhFTB2Q0iZcGsatdnfeZEDU16uv+/u3XRgiEPUE4XhI+IndGCCoxAEzOGHi23UQkialvpaNiGk3bvFYorqe2fbJqvfrTCGkNI5MEBqGIl1YIgjjA4MIX7BJN7gyBcBk24a9YQJYmsmYJzMQpL4EULStK7rOmUTQpJ5K0DuOTBO38eJAwO4I2DowBQoqoChA0P8RL2jpQPjL4WQxGsmYMI+CwnoGkZy0mYpYBIJsS0u7jrTNJs2mf1uBQUM8Q2GkEhQ0IEJjrIyoLRU/z2qx98oYDo79eURpIDZulUPy4Q1hKQuHmklYJw4MJIePbLPa3QrhJSNgGEhO2ILhpBIUDCJN1hUFyaqx99YB2b3biFiYjFg7FixPXRIFzVhTeJVP884ldpJCKlbt9Q+PZfv1Y0QUs+eXR0ZI6qAybYOzIED+tIFQUABExAMIZGgYBJvsOSTgJEOjMx/6dtXnFNqIm9Hhz5AOlnMUeK1gLGaSu0khASkujDZTqEG3AkhZUrgBXILIamiLshEXgqYgJAnSq9eXe1HQryEIaRgUQe3qApIo4CR+S/9+4vtkCFi+8knupMBhC+EpH5eLiEkILUfz+W6ciOElCl8BOQmYIqL9eMSZBiJAiYgpAPD8BHxGybxBks+OjB2BEw8bi+xNYohJON+boWQSkrsJwOrDozXAgYIRzE7CpiAkCfpsGHBtoMUHnRggqXQBIzTUIzfDowXISS3HBgn7+M0hHTYYWKbrYAJQyJvhjQf4hU/+hHQ0ABcemnQLSGFBnNggkUVMFIIRA1jHRg7Dky2AsYvByaMISQn75NtCOnzz/X/MRsBE2QODAVMQBx2GHDvvUG3ghQinIUULFLAdO8OFEXUA7dK4q2tFVspYD7+ODcBU1zcdXqw27gVQnJLwGTr0GWbxLtnDzBggHjsRMAcd5yYJm/3e/UCChhCCgyGkIJFFTBRJVMISeb25erAeB0+AvIzhGTHgZEiR9P078+JgLnvPvv7ekVE9T8hJFuYxBssUsBEWTwa68AYBczgwWLb0gJs2yYe23Uy1OPidfhI/TxVwHR06OIsGwfGrWnU2YaQ7DgwpaV6GGj3brH1QzC6CQUMIQUGHZhgyScBc/Bg6h28FDDdu+tJohs2iK1dJ0OdeeOngFFDSE6nfgPhCiHZcWAAPYwk8eN4uwkFDCEFBpN4gyWfBExHB/Dll7pbIXNgAD0PxqmAAfRjE1QISYaP7E79BtybRu1XCAmggCGERIzycnG3WF5uv6Mj7pFPOTAAsGWL2PbsmTrgSgGzcaP+ul3k+wQVQnI6AwkIVw6MnRASEH0BwyReQgqMkhLgtdeA9vboTuONMjI/ZNCgYNuRC6oz8tFHYivDRxIpYGRoJkoCxukMJMA9AROPi3yWzk5vp1EDFDCEkAgyblzQLShczj4beOkl4IQTgm5J9sRiYrBrbbUWMMYq42EPIak5ME5nIAHuCZhYTPx9czMdmExQwBBCiI8UFwPf+U7Qrcid8vL0AkY6MBInboYMsxWiAyP/3qmAqaoS9VzKy+0LLwoYQgghBUd5uSgjL3Ng1AReoKuAiVIIKdccmFymUat/7yRPqrQUeO894cTYLZBIAUMIIaTgkPlTUsBkcmDCGkIym0YdZAhJ/Xun7+NEcAFdBYzdGVdhgbOQCCGEOEYKmI8/FlujgKmuTh1Qw+rASJdjzx69oFs2IaTu3fVE2qAEjFNUAROPi/ybKEEBQwghxDFqLRigq4ABUl2YsAoYmfC6YwfQr59IcH/2WfGcEwETi4kE7WHDuiYwO+W448T7jR6d2/tkwihgogYFDCGEEMcYp+Abc2CA1IHciRjwM4R01FHA7bcLsaBpQH098M474jWnIZkXXgDefz/3dt93nxBU3/xmbu+TiagLGObAEEIIcYxRwLjpwMhaOXKVZC+JxYDf/Eb87NghaiS9+qpYw+nHP3b+Xm6snl1UBNTU5P4+maiuFp+VSFDAEEIIKRBUl6GszLz2SLYC5rLLhIg57bTs25cN/fsDF14ofgqB4mLxve3eHU0BwxASIYQQx6gOTG2teQKoFDBFRc6mBHfrBnzve85ED8kOGUaigCGEEFIQGAWMGTIHpmfP6M1wKRSiLGAYQiKEEOIYVcCY5b8AwJgxwHnnAcce60+biHMOO0xsKWAIIYQUBHYETEkJ8Je/+NMekh1RdmAYQiKEEOIYOwKGhB8pYPyYsu42FDCEEEIcQwGTH9CBIYQQUlDYSeIl4efb3wYOPxz47neDbolzmANDCCHEMWrIgQ5MdBk9Gvj006BbkR10YAghhDiGISQSNBQwhBBCHCMFTCwmFkEkxG8oYAghhDhGCpi+fYHS0mDbQgoTChhCCCGOkQXQjjwy2HaQwsWxgFm+fDnOOeccDBgwALFYDM8//3zK65qm4eabb0b//v1RXl6OiRMnYvPmzSn77NmzB1OnTkVlZSWqq6sxbdo07Nu3L2Wf9evX4+STT0a3bt0waNAg3HXXXc7/O0IIIZ5QVwc8/LD4ISQIHAuY/fv349hjj8WcOXNMX7/rrrtw3333Ye7cuVizZg169OiBSZMm4dChQ8l9pk6dio0bN2LRokVYsGABli9fjp///OfJ15ubm3HmmWdiyJAhqK+vx913341bbrkFDz30UBb/IiGEELeJxcSq0aNHB90SUrBoOQBAe+6555K/JxIJrba2Vrv77ruTz+3du1eLx+PaU089pWmapm3atEkDoL355pvJfV555RUtFotpn332maZpmvbAAw9ovXr10lpbW5P7XH/99drw4cNtt62pqUkDoDU1NWX77xFCCCHEZ+yO367mwGzZsgWNjY2YOHFi8rmqqiqMHz8eq1atAgCsWrUK1dXVGDduXHKfiRMnoqioCGvWrEnuc8opp6CsrCy5z6RJk9DQ0IAvv/zS9LNbW1vR3Nyc8kMIIYSQ/MRVAdPY2AgAqKmpSXm+pqYm+VpjYyP6GebclZSUoHfv3in7mL2H+hlGZs2ahaqqquTPoEGDcv+HCCGEEBJK8mYW0g033ICmpqbkz7Zt24JuEiGEEEI8wlUBU/vVghg7d+5MeX7nzp3J12pra7Fr166U1zs6OrBnz56UfczeQ/0MI/F4HJWVlSk/hBBCCMlPXBUwQ4cORW1tLRYvXpx8rrm5GWvWrEFdXR0AoK6uDnv37kV9fX1ynyVLliCRSGD8+PHJfZYvX4729vbkPosWLcLw4cPRq1cvN5tMCCGEkAjiWMDs27cP69atw7p16wCIxN1169Zh69atiMVimDFjBv7rv/4LL7zwAjZs2ICLLroIAwYMwLnnngsAGDlyJM466yxcfvnleOONN/CPf/wDV111FX7yk59gwIABAICf/vSnKCsrw7Rp07Bx40b83//9H+69915cc801rv3jhBBCCIkwTqc3vf766xqALj8XX3yxpmliKvVNN92k1dTUaPF4XDvjjDO0hoaGlPf44osvtPPPP1+rqKjQKisrtUsuuURraWlJ2eedd97RTjrpJC0ej2uHH364dueddzpqJ6dRE0IIIdHD7vgd0zRNC1A/eUZzczOqqqrQ1NTEfBhCCCEkItgdv/NmFhIhhBBCCgcKGEIIIYREDgoYQgghhEQOChhCCCGERI6SoBvgFTI3mWsiEUIIIdFBjtuZ5hjlrYBpaWkBAK6JRAghhESQlpYWVFVVWb6et9OoE4kEtm/fjp49eyIWi7n2vs3NzRg0aBC2bdvG6dkew2PtLzze/sFj7R881v7h1rHWNA0tLS0YMGAAioqsM13y1oEpKirCwIEDPXt/rrfkHzzW/sLj7R881v7BY+0fbhzrdM6LhEm8hBBCCIkcFDCEEEIIiRwUMA6Jx+P4z//8T8Tj8aCbkvfwWPsLj7d/8Fj7B4+1f/h9rPM2iZcQQggh+QsdGEIIIYREDgoYQgghhEQOChhCCCGERA4KGEIIIYREDgoYh8yZMwdHHHEEunXrhvHjx+ONN94IukmRZ9asWfjmN7+Jnj17ol+/fjj33HPR0NCQss+hQ4cwffp09OnTBxUVFZgyZQp27twZUIvzhzvvvBOxWAwzZsxIPsdj7R6fffYZLrjgAvTp0wfl5eUYPXo03nrrreTrmqbh5ptvRv/+/VFeXo6JEydi8+bNAbY4mnR2duKmm27C0KFDUV5ejq997Wu47bbbUtbS4bHOjuXLl+Occ87BgAEDEIvF8Pzzz6e8bue47tmzB1OnTkVlZSWqq6sxbdo07Nu3L/fGacQ28+fP18rKyrQ//vGP2saNG7XLL79cq66u1nbu3Bl00yLNpEmTtMcee0x79913tXXr1mnf+c53tMGDB2v79u1L7nPFFVdogwYN0hYvXqy99dZb2oQJE7RvfetbAbY6+rzxxhvaEUccoX3jG9/Qrr766uTzPNbusGfPHm3IkCHaz372M23NmjXaRx99pC1cuFD75z//mdznzjvv1KqqqrTnn39ee+edd7Tvfe972tChQ7WDBw8G2PLocfvtt2t9+vTRFixYoG3ZskV75plntIqKCu3ee+9N7sNjnR0vv/yy9h//8R/as88+qwHQnnvuuZTX7RzXs846Szv22GO11atXa3//+9+1YcOGaeeff37ObaOAccAJJ5ygTZ8+Pfl7Z2enNmDAAG3WrFkBtir/2LVrlwZAW7ZsmaZpmrZ3716ttLRUe+aZZ5L7vPfeexoAbdWqVUE1M9K0tLRoRx11lLZo0SLtX/7lX5IChsfaPa6//nrtpJNOsnw9kUhotbW12t133518bu/evVo8HteeeuopP5qYN0yePFm79NJLU54777zztKlTp2qaxmPtFkYBY+e4btq0SQOgvfnmm8l9XnnlFS0Wi2mfffZZTu1hCMkmbW1tqK+vx8SJE5PPFRUVYeLEiVi1alWALcs/mpqaAAC9e/cGANTX16O9vT3l2I8YMQKDBw/msc+S6dOnY/LkySnHFOCxdpMXXngB48aNw49+9CP069cPY8aMwcMPP5x8fcuWLWhsbEw51lVVVRg/fjyPtUO+9a1vYfHixfjggw8AAO+88w5WrFiBs88+GwCPtVfYOa6rVq1CdXU1xo0bl9xn4sSJKCoqwpo1a3L6/LxdzNFtdu/ejc7OTtTU1KQ8X1NTg/fffz+gVuUfiUQCM2bMwIknnohjjjkGANDY2IiysjJUV1en7FtTU4PGxsYAWhlt5s+fj7fffhtvvvlml9d4rN3jo48+woMPPohrrrkGv/nNb/Dmm2/il7/8JcrKynDxxRcnj6dZn8Jj7Yxf//rXaG5uxogRI1BcXIzOzk7cfvvtmDp1KgDwWHuEnePa2NiIfv36pbxeUlKC3r1753zsKWBIqJg+fTreffddrFixIuim5CXbtm3D1VdfjUWLFqFbt25BNyevSSQSGDduHO644w4AwJgxY/Duu+9i7ty5uPjiiwNuXX7x9NNP44knnsCTTz6Jo48+GuvWrcOMGTMwYMAAHus8hiEkm/Tt2xfFxcVdZmPs3LkTtbW1AbUqv7jqqquwYMECvP766xg4cGDy+draWrS1tWHv3r0p+/PYO6e+vh67du3C2LFjUVJSgpKSEixbtgz33XcfSkpKUFNTw2PtEv3798eoUaNSnhs5ciS2bt0KAMnjyT4ld6699lr8+te/xk9+8hOMHj0aF154IWbOnIlZs2YB4LH2CjvHtba2Frt27Up5vaOjA3v27Mn52FPA2KSsrAzHH388Fi9enHwukUhg8eLFqKurC7Bl0UfTNFx11VV47rnnsGTJEgwdOjTl9eOPPx6lpaUpx76hoQFbt27lsXfIGWecgQ0bNmDdunXJn3HjxmHq1KnJxzzW7nDiiSd2KQfwwQcfYMiQIQCAoUOHora2NuVYNzc3Y82aNTzWDjlw4ACKilKHs+LiYiQSCQA81l5h57jW1dVh7969qK+vT+6zZMkSJBIJjB8/PrcG5JQCXGDMnz9fi8fj2rx587RNmzZpP//5z7Xq6mqtsbEx6KZFmiuvvFKrqqrSli5dqu3YsSP5c+DAgeQ+V1xxhTZ48GBtyZIl2ltvvaXV1dVpdXV1AbY6f1BnIWkaj7VbvPHGG1pJSYl2++23a5s3b9aeeOIJrXv37tqf/vSn5D533nmnVl1drf31r3/V1q9fr33/+9/n1N4suPjii7XDDz88OY362Wef1fr27atdd911yX14rLOjpaVFW7t2rbZ27VoNgPa73/1OW7t2rfbJJ59ommbvuJ511lnamDFjtDVr1mgrVqzQjjrqKE6jDoLf//732uDBg7WysjLthBNO0FavXh10kyIPANOfxx57LLnPwYMHtX/7t3/TevXqpXXv3l37wQ9+oO3YsSO4RucRRgHDY+0eL774onbMMcdo8XhcGzFihPbQQw+lvJ5IJLSbbrpJq6mp0eLxuHbGGWdoDQ0NAbU2ujQ3N2tXX321NnjwYK1bt27akUceqf3Hf/yH1tramtyHxzo7Xn/9ddP++eKLL9Y0zd5x/eKLL7Tzzz9fq6io0CorK7VLLrlEa2lpybltMU1TShUSQgghhEQA5sAQQgghJHJQwBBCCCEkclDAEEIIISRyUMAQQgghJHJQwBBCCCEkclDAEEIIISRyUMAQQgghJHJQwBBCCCEkclDAEEIIISRyUMAQQgghJHJQwBBCCCEkclDAEEIIISRy/H+Yc7lT2c/VtAAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Build the number of steps per episode graph\n",
        "ig, ax = plt.subplots()\n",
        "ax.plot(num_steps_per_ep, color='blue')"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "py11",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.2"
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "dfed9117f0764c80b502186e430bd49c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_13232e74996841a0b4c253154f9c3aaf",
              "IPY_MODEL_e49d7de3da184c12b4a8ff88fbb0b167",
              "IPY_MODEL_8ffab7255d1142e49d9faf713ed238e6"
            ],
            "layout": "IPY_MODEL_596b5bf3db26456cade8a073cc4e9d17"
          }
        },
        "13232e74996841a0b4c253154f9c3aaf": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_d1f2e1d026084530972bf942a4c0f557",
            "placeholder": "​",
            "style": "IPY_MODEL_e0f3033b89ad42e68248ceb0ba4f7346",
            "value": " 79%"
          }
        },
        "e49d7de3da184c12b4a8ff88fbb0b167": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_c48e6dc5554a440bb6c461169b08e7bd",
            "max": 100,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_d1db8966138845039fcde3416c99c6bc",
            "value": 79
          }
        },
        "8ffab7255d1142e49d9faf713ed238e6": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_c4804329fdec4925bc43d1690a44ce64",
            "placeholder": "​",
            "style": "IPY_MODEL_1428627440f641c693921ed25ebd7edc",
            "value": " 79/100 [16:52&lt;04:51, 13.88s/it]"
          }
        },
        "596b5bf3db26456cade8a073cc4e9d17": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "d1f2e1d026084530972bf942a4c0f557": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "e0f3033b89ad42e68248ceb0ba4f7346": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "c48e6dc5554a440bb6c461169b08e7bd": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "d1db8966138845039fcde3416c99c6bc": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "c4804329fdec4925bc43d1690a44ce64": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "1428627440f641c693921ed25ebd7edc": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}