File size: 204,349 Bytes

53ab640

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "view-in-github",
    "colab_type": "text"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/IOAI-official/IOAI-2026/blob/main/Home%20Task/Home-Task-2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zetN4ubB12vc"
   },
   "source": [
    "# Robot Delivery Academy: Preparatory Program\n",
    "\n",
    "## 1. Problem Description\n",
    "\n",
    "Welcome to the **Robot Delivery Academy**, the preparatory program for the Robot Training task.\n",
    "\n",
    "You are working with a small delivery robot on an `8 x 8` city map. In each episode, the robot starts somewhere on the map, picks up a package from one depot, and delivers it to another depot. Some cells are blocked, and every map is slightly different.\n",
    "\n",
    "For a human programmer, this kind of task may look easy: inspect the map, find a path, pick up the package, deliver it. But the goal here is different. We want to check whether an AI model can learn this behavior from examples instead of being given the full hand-written strategy.\n",
    "\n",
    "The training principle is supervised learning. We prepare many examples of the form:\n",
    "\n",
    "```text\n",
    "observation -> action\n",
    "```\n",
    "\n",
    "The model sees what action was taken in each situation and tries to learn the pattern. Later, it must act on new scenarios where the answers are not provided.\n",
    "\n",
    "### Your Mission\n",
    "\n",
    "Train a model that can:\n",
    "\n",
    "1. Learn from provided demonstrations.\n",
    "2. Predict a useful next action from the current observation.\n",
    "3. Run for a complete episode and deliver the package.\n",
    "4. Generalize to validation and test scenarios that were not shown as demonstrations.\n",
    "\n",
    "### The Challenge\n",
    "\n",
    "You are given a deliberately small demonstration budget. The interesting question is not whether the task can be solved by a search algorithm, but whether you can train a model that learns enough from limited examples.\n",
    "\n",
    "A single wrong action can move the robot into states that were rare in the demonstrations, so high action accuracy does not always mean high episode success.\n"
   ],
   "id": "zetN4ubB12vc"
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MP0HNTo412ve"
   },
   "source": [
    "## 2. Download the data\n",
    "\n",
    "This task's data (three `.pkl` files) lives in the shared **`IOAI-2026/RobotDelivery`** Drive folder. The cell below downloads it into a local `data/` folder — no sign-in or setup, just run it."
   ],
   "id": "MP0HNTo412ve",
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c12b1a1b",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "c12b1a1b",
    "outputId": "7fb339c3-0622-4f3b-cfda-bf3f844aa5bd"
   },
   "outputs": [],
   "source": [
    "!pip install -q gdown\n",
    "import os\n",
    "from pathlib import Path\n",
    "import gdown\n",
    "\n",
    "# Data lives in the shared IOAI-2026/RobotDelivery folder (public link, no sign-in).\n",
    "DATA_DIR = Path('data')\n",
    "if not DATA_DIR.exists() or not any(DATA_DIR.iterdir()):\n",
    "    gdown.download_folder(id='1DXFDoY9bqulMBFacyDShVIx8Sa7Z5Wpa',\n",
    "                          output=str(DATA_DIR), quiet=True, use_cookies=False)\n",
    "os.listdir(DATA_DIR)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "611ad339",
   "metadata": {
    "id": "611ad339"
   },
   "source": [
    "## 3. Understanding the Task Simulator\n",
    "\n",
    "For this preparatory task, we also provide a small simulator. It is mainly here to make the task easier to understand: you can use it to inspect scenario conditions, replay demonstration trajectories, and visualize the solutions produced by your model.\n",
    "\n",
    "The task is a small grid delivery problem.\n",
    "\n",
    "- The grid size is `8 x 8`.\n",
    "- There are six depot cells: `A`, `B`, `C`, `D`, `E`, `F`.\n",
    "- One depot contains the package.\n",
    "- Another depot is the destination.\n",
    "- The robot must move to the package, pick it up, move to the destination, and drop it off.\n",
    "- Walls block movement.\n",
    "\n",
    "The simulator is included directly in this notebook so it works as a single Google Colab file. It is used to show examples and to check complete episodes after training. The visual helper below can also save and display animated GIFs.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c0957a9",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9c0957a9",
    "outputId": "441f3e83-7922-4af9-816c-788ea5f25bf3"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "data dir: data\n",
      "device: cpu\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "import pickle\n",
    "import random\n",
    "import zipfile\n",
    "from collections import Counter\n",
    "from pathlib import Path\n",
    "from typing import Any\n",
    "\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "from IPython.display import Image as NotebookImage, display\n",
    "from PIL import Image as PILImage, ImageDraw\n",
    "from tqdm.auto import tqdm\n",
    "\n",
    "SEED = 42\n",
    "random.seed(SEED)\n",
    "np.random.seed(SEED)\n",
    "torch.manual_seed(SEED)\n",
    "\n",
    "GRID_SIZE = 8\n",
    "N_DEPOTS = 6\n",
    "MAX_STEPS = 120\n",
    "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "ACTION_NAMES = {\n",
    "    0: \"south\",\n",
    "    1: \"north\",\n",
    "    2: \"east\",\n",
    "    3: \"west\",\n",
    "    4: \"pickup\",\n",
    "    5: \"dropoff\",\n",
    "}\n",
    "\n",
    "ACTION_DELTAS = {\n",
    "    0: (1, 0),\n",
    "    1: (-1, 0),\n",
    "    2: (0, 1),\n",
    "    3: (0, -1),\n",
    "}\n",
    "\n",
    "DEPOT_NAMES = [\"A\", \"B\", \"C\", \"D\", \"E\", \"F\"]\n",
    "\n",
    "print(\"data dir:\", DATA_DIR)\n",
    "print(\"device:\", DEVICE)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c226bae",
   "metadata": {
    "id": "1c226bae"
   },
   "outputs": [],
   "source": [
    "class DeliverySimulator8x8:\n",
    "    \"\"\"Run one 8x8 delivery episode.\"\"\"\n",
    "\n",
    "    def reset(self, scenario: dict[str, Any]) -> tuple[int, int, int, int]:\n",
    "        \"\"\"Start a scenario and return the compact state.\"\"\"\n",
    "        self.step_count = 0\n",
    "        self.carrying = False\n",
    "        self.walls = {tuple(cell) for cell in scenario[\"walls\"]}\n",
    "        self.depots = [tuple(cell) for cell in scenario[\"depots\"]]\n",
    "        self.agent_pos = tuple(scenario[\"agent_pos\"])\n",
    "        self.package_location = int(scenario[\"package_location\"])\n",
    "        self.destination = int(scenario[\"destination\"])\n",
    "        return self.state()\n",
    "\n",
    "    def state(self) -> tuple[int, int, int, int]:\n",
    "        \"\"\"Return row, column, package field, and destination.\"\"\"\n",
    "        package_field = N_DEPOTS if self.carrying else self.package_location\n",
    "        return int(self.agent_pos[0]), int(self.agent_pos[1]), int(package_field), int(self.destination)\n",
    "\n",
    "    def can_enter(self, row: int, col: int) -> bool:\n",
    "        \"\"\"Check whether the robot can occupy a cell.\"\"\"\n",
    "        return 0 <= row < GRID_SIZE and 0 <= col < GRID_SIZE and (row, col) not in self.walls\n",
    "\n",
    "    def valid_action_mask(self) -> np.ndarray:\n",
    "        \"\"\"Return the currently valid actions.\"\"\"\n",
    "        row, col, _, destination = self.state()\n",
    "        mask = np.zeros(6, dtype=bool)\n",
    "        for action, (dr, dc) in ACTION_DELTAS.items():\n",
    "            mask[action] = self.can_enter(row + dr, col + dc)\n",
    "        mask[4] = (not self.carrying) and self.agent_pos == self.depots[self.package_location]\n",
    "        mask[5] = self.carrying and self.agent_pos == self.depots[destination]\n",
    "        return mask\n",
    "\n",
    "    def observation(self) -> dict[str, Any]:\n",
    "        \"\"\"Build the model observation for the current state.\"\"\"\n",
    "        row, col, package_field, destination = self.state()\n",
    "        carrying = package_field == N_DEPOTS\n",
    "        dest_row, dest_col = self.depots[destination]\n",
    "        target_row, target_col = (dest_row, dest_col) if carrying else self.depots[package_field]\n",
    "\n",
    "        grid = np.zeros((6, GRID_SIZE, GRID_SIZE), dtype=np.float32)\n",
    "        for wr, wc in self.walls:\n",
    "            grid[0, wr, wc] = 1.0\n",
    "        for dr, dc in self.depots:\n",
    "            grid[1, dr, dc] = 1.0\n",
    "        grid[2, row, col] = 1.0\n",
    "        if not carrying:\n",
    "            pr, pc = self.depots[package_field]\n",
    "            grid[3, pr, pc] = 1.0\n",
    "        grid[4, dest_row, dest_col] = 1.0\n",
    "        grid[5, :, :] = float(carrying)\n",
    "\n",
    "        blocked_moves = [float(not self.can_enter(row + dr, col + dc)) for dr, dc in ACTION_DELTAS.values()]\n",
    "        vector = np.array(\n",
    "            [\n",
    "                row / (GRID_SIZE - 1),\n",
    "                col / (GRID_SIZE - 1),\n",
    "                package_field / N_DEPOTS,\n",
    "                destination / (N_DEPOTS - 1),\n",
    "                float(carrying),\n",
    "                target_row / (GRID_SIZE - 1),\n",
    "                target_col / (GRID_SIZE - 1),\n",
    "                (target_row - row) / (GRID_SIZE - 1),\n",
    "                (target_col - col) / (GRID_SIZE - 1),\n",
    "                *blocked_moves,\n",
    "            ],\n",
    "            dtype=np.float32,\n",
    "        )\n",
    "        return {\"grid\": grid, \"vector\": vector, \"action_mask\": self.valid_action_mask(), \"state\": self.state()}\n",
    "\n",
    "    def step(self, action: int) -> tuple[tuple[int, int, int, int], bool, bool, dict[str, Any]]:\n",
    "        \"\"\"Apply one action and report episode status.\"\"\"\n",
    "        action = int(action)\n",
    "        done = False\n",
    "        info = {\"invalid_pickup_or_dropoff\": False}\n",
    "\n",
    "        if action in ACTION_DELTAS:\n",
    "            dr, dc = ACTION_DELTAS[action]\n",
    "            row, col = self.agent_pos[0] + dr, self.agent_pos[1] + dc\n",
    "            if self.can_enter(row, col):\n",
    "                self.agent_pos = (row, col)\n",
    "        elif action == 4 and (not self.carrying) and self.agent_pos == self.depots[self.package_location]:\n",
    "            self.carrying = True\n",
    "        elif action == 5 and self.carrying and self.agent_pos == self.depots[self.destination]:\n",
    "            done = True\n",
    "            self.carrying = False\n",
    "            self.package_location = self.destination\n",
    "        elif action in (4, 5):\n",
    "            info[\"invalid_pickup_or_dropoff\"] = True\n",
    "        else:\n",
    "            raise ValueError(f\"unknown action: {action}\")\n",
    "\n",
    "        self.step_count += 1\n",
    "        return self.state(), done, self.step_count >= MAX_STEPS and not done, info\n",
    "\n",
    "    def render(self) -> str:\n",
    "        \"\"\"Return an ASCII rendering of the current grid.\"\"\"\n",
    "        grid = [[\".\" for _ in range(GRID_SIZE)] for _ in range(GRID_SIZE)]\n",
    "        for row, col in self.walls:\n",
    "            grid[row][col] = \"#\"\n",
    "        for i, (row, col) in enumerate(self.depots):\n",
    "            grid[row][col] = DEPOT_NAMES[i]\n",
    "\n",
    "        agent_row, agent_col = self.agent_pos\n",
    "        grid[agent_row][agent_col] = \"T*\" if self.carrying else \"T\"\n",
    "        rows = [\" \".join(f\"{cell:>2}\" for cell in row) for row in grid]\n",
    "        package_name = \"in taxi\" if self.carrying else DEPOT_NAMES[self.package_location]\n",
    "        rows.append(f\"package={package_name}, destination={DEPOT_NAMES[self.destination]}\")\n",
    "        return \"\\n\".join(rows)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94500d0f",
   "metadata": {
    "id": "94500d0f"
   },
   "outputs": [],
   "source": [
    "CELL_SIZE = 56\n",
    "FRAME_FOOTER = 44\n",
    "DEPOT_COLORS = [\"#ef4444\", \"#3b82f6\", \"#22c55e\", \"#f59e0b\", \"#a855f7\", \"#06b6d4\"]\n",
    "\n",
    "\n",
    "def draw_episode_frame(simulator, step=0, action_name=\"start\"):\n",
    "    \"\"\"Render the current simulator state as a PIL image.\"\"\"\n",
    "    width = GRID_SIZE * CELL_SIZE\n",
    "    height = GRID_SIZE * CELL_SIZE + FRAME_FOOTER\n",
    "    image = PILImage.new(\"RGB\", (width, height), \"#f8fafc\")\n",
    "    draw = ImageDraw.Draw(image)\n",
    "\n",
    "    for row in range(GRID_SIZE):\n",
    "        for col in range(GRID_SIZE):\n",
    "            x0, y0 = col * CELL_SIZE, row * CELL_SIZE\n",
    "            x1, y1 = x0 + CELL_SIZE, y0 + CELL_SIZE\n",
    "            fill = \"#334155\" if (row, col) in simulator.walls else \"#f8fafc\"\n",
    "            draw.rectangle([x0, y0, x1, y1], fill=fill, outline=\"#cbd5e1\")\n",
    "\n",
    "    target_id = simulator.destination if simulator.carrying else simulator.package_location\n",
    "    for depot_id, (row, col) in enumerate(simulator.depots):\n",
    "        x0, y0 = col * CELL_SIZE + 8, row * CELL_SIZE + 8\n",
    "        x1, y1 = x0 + CELL_SIZE - 16, y0 + CELL_SIZE - 16\n",
    "        color = DEPOT_COLORS[depot_id]\n",
    "        draw.rounded_rectangle([x0, y0, x1, y1], radius=10, fill=color)\n",
    "        draw.text((x0 + 14, y0 + 9), DEPOT_NAMES[depot_id], fill=\"white\")\n",
    "        if depot_id == target_id:\n",
    "            draw.rounded_rectangle([x0 - 4, y0 - 4, x1 + 4, y1 + 4], radius=14, outline=\"#111827\", width=4)\n",
    "\n",
    "    row, col = simulator.agent_pos\n",
    "    cx, cy = col * CELL_SIZE + CELL_SIZE // 2, row * CELL_SIZE + CELL_SIZE // 2\n",
    "    draw.ellipse([cx - 18, cy - 18, cx + 18, cy + 18], fill=\"#111827\")\n",
    "    draw.text((cx - 5, cy - 8), \"T\", fill=\"white\")\n",
    "    if simulator.carrying:\n",
    "        draw.rectangle([cx + 10, cy - 24, cx + 25, cy - 9], fill=\"#f97316\", outline=\"#9a3412\")\n",
    "\n",
    "    package = \"in robot\" if simulator.carrying else DEPOT_NAMES[simulator.package_location]\n",
    "    footer = f\"step {step:02d} | action: {action_name} | package: {package} -> {DEPOT_NAMES[simulator.destination]}\"\n",
    "    draw.rectangle([0, GRID_SIZE * CELL_SIZE, width, height], fill=\"#e2e8f0\")\n",
    "    draw.text((12, GRID_SIZE * CELL_SIZE + 14), footer, fill=\"#0f172a\")\n",
    "    return image\n",
    "\n",
    "\n",
    "def show_episode_gif(scenario, actions, path=\"episode.gif\", duration=450):\n",
    "    \"\"\"Save and display an animated GIF for one action sequence.\"\"\"\n",
    "    simulator = DeliverySimulator8x8()\n",
    "    simulator.reset(scenario)\n",
    "    frames = [draw_episode_frame(simulator)]\n",
    "    for step, action in enumerate(actions, start=1):\n",
    "        simulator.step(action)\n",
    "        frames.append(draw_episode_frame(simulator, step, ACTION_NAMES[action]))\n",
    "    frames[0].save(path, save_all=True, append_images=frames[1:], duration=duration, loop=0)\n",
    "    display(NotebookImage(filename=path))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93720bc4",
   "metadata": {
    "id": "93720bc4"
   },
   "source": [
    "## 4. Dataset\n",
    "\n",
    "### 4.1 Provided Training Data\n",
    "\n",
    "You are provided with expert demonstrations saved in `data/train_demos.pkl`.\n",
    "\n",
    "Each trajectory contains observations and expert actions from one successful delivery episode.\n",
    "\n",
    "**Data Format:**\n",
    "\n",
    "```python\n",
    "{\n",
    "    \"trajectories\": [\n",
    "        {\n",
    "            \"layout_id\": str,\n",
    "            \"episode_seed\": int,\n",
    "            \"scenario\": dict,\n",
    "            \"observations\": [\n",
    "                {\n",
    "                    \"grid\": np.array,       # shape: (6, 8, 8)\n",
    "                    \"vector\": np.array,     # shape: (13,)\n",
    "                    \"action_mask\": np.array,# shape: (6,)\n",
    "                    \"state\": tuple\n",
    "                },\n",
    "                ...\n",
    "            ],\n",
    "            \"actions\": [int, ...],       # action IDs 0-5\n",
    "            \"success\": bool,\n",
    "            \"num_steps\": int\n",
    "        },\n",
    "        ...\n",
    "    ]\n",
    "}\n",
    "```\n",
    "\n",
    "### 4.2 Validation and Test Scenarios\n",
    "\n",
    "You are also provided with:\n",
    "\n",
    "- `data/valid_scenarios.pkl`\n",
    "- `data/test_scenarios.pkl`\n",
    "\n",
    "These files contain delivery scenarios without expert action labels. They are used to run your trained model and check complete-episode success.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53bd4d78",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "53bd4d78",
    "outputId": "fa942225-df29-469f-f7de-a16bf9684a93"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Loaded data\n",
      "  training demonstrations: 400\n",
      "  validation scenarios: 200\n",
      "  test scenarios: 1600\n",
      "  training state-action samples: 5327\n",
      "  average demonstration length: 13.32\n",
      "  expert success rate: 100.0%\n"
     ]
    }
   ],
   "source": [
    "with (DATA_DIR / \"train_demos.pkl\").open(\"rb\") as f:\n",
    "    train_data = pickle.load(f)\n",
    "with (DATA_DIR / \"valid_scenarios.pkl\").open(\"rb\") as f:\n",
    "    valid_scenarios = pickle.load(f)\n",
    "with (DATA_DIR / \"test_scenarios.pkl\").open(\"rb\") as f:\n",
    "    test_scenarios = pickle.load(f)\n",
    "\n",
    "train_trajectories = train_data[\"trajectories\"]\n",
    "steps = [t[\"num_steps\"] for t in train_trajectories]\n",
    "\n",
    "print(\"Loaded data\")\n",
    "print(\"  training demonstrations:\", len(train_trajectories))\n",
    "print(\"  validation scenarios:\", len(valid_scenarios))\n",
    "print(\"  test scenarios:\", len(test_scenarios))\n",
    "print(\"  training state-action samples:\", sum(steps))\n",
    "print(\"  average demonstration length:\", f\"{np.mean(steps):.2f}\")\n",
    "print(\"  expert success rate:\", f\"{100 * np.mean([t['success'] for t in train_trajectories]):.1f}%\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "787aadc4",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 940
    },
    "id": "787aadc4",
    "outputId": "d2d83396-90f4-4081-d085-a1fb81984f3c"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Example trajectory\n",
      "  layout_id: train_0000\n",
      "  episode_seed: 100000\n",
      "  num_steps: 23\n",
      "  actions: ['north', 'north', 'north', 'east', 'east', 'east', 'east', 'east', 'pickup', 'south', 'west', 'south', 'south', 'south', 'south', 'south', 'west', 'west', 'west', 'west', 'west', 'west', 'dropoff']\n",
      "\n",
      "Observation\n",
      "  grid shape: (6, 8, 8)\n",
      "  vector shape: (13,)\n",
      "  valid actions: ['south', 'north', 'east']\n",
      "\n",
      "Initial frame\n",
      " .  .  .  .  .  .  .  A\n",
      " .  #  .  .  E  #  D  .\n",
      " .  .  .  .  .  .  .  #\n",
      " .  #  T  .  .  #  .  .\n",
      " F  .  .  #  #  .  .  .\n",
      " .  .  .  .  .  #  .  .\n",
      " B  .  .  .  .  .  .  .\n",
      " .  .  .  .  .  .  .  .\n",
      "package=A, destination=B\n",
      "\n",
      "Animated example\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "image/gif": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {}
    }
   ],
   "source": [
    "example = train_trajectories[0]\n",
    "print(\"Example trajectory\")\n",
    "print(\"  layout_id:\", example[\"layout_id\"])\n",
    "print(\"  episode_seed:\", example[\"episode_seed\"])\n",
    "print(\"  num_steps:\", example[\"num_steps\"])\n",
    "print(\"  actions:\", [ACTION_NAMES[a] for a in example[\"actions\"]])\n",
    "\n",
    "obs0 = example[\"observations\"][0]\n",
    "print(\"\\nObservation\")\n",
    "print(\"  grid shape:\", obs0[\"grid\"].shape)\n",
    "print(\"  vector shape:\", obs0[\"vector\"].shape)\n",
    "print(\"  valid actions:\", [ACTION_NAMES[i] for i, ok in enumerate(obs0[\"action_mask\"]) if ok])\n",
    "\n",
    "simulator = DeliverySimulator8x8()\n",
    "simulator.reset(example[\"scenario\"])\n",
    "print(\"\\nInitial frame\")\n",
    "print(simulator.render())\n",
    "\n",
    "print(\"\\nAnimated example\")\n",
    "show_episode_gif(example[\"scenario\"], example[\"actions\"], path=\"expert_demo.gif\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e339fe9e",
   "metadata": {
    "id": "e339fe9e"
   },
   "source": [
    "## 5. Task\n",
    "\n",
    "### 5.1 Objective\n",
    "\n",
    "Train a behavioral cloning action model that:\n",
    "\n",
    "1. Takes the current observation as input.\n",
    "2. Predicts the expert's next action.\n",
    "3. Runs step by step in a full delivery episode.\n",
    "4. Achieves high success rate on validation and test scenarios.\n",
    "\n",
    "### 5.2 Input and Output\n",
    "\n",
    "**Input observation:**\n",
    "\n",
    "- `grid`: `6 x 8 x 8` tensor with walls, depots, robot position, package position, destination, and carrying flag.\n",
    "- `vector`: 13 numerical features with normalized position and target information.\n",
    "- `action_mask`: 6 binary values showing which actions are currently valid.\n",
    "\n",
    "**Output action:**\n",
    "\n",
    "A single integer from `0` to `5`:\n",
    "\n",
    "| id | action |\n",
    "|---:|---|\n",
    "| 0 | south |\n",
    "| 1 | north |\n",
    "| 2 | east |\n",
    "| 3 | west |\n",
    "| 4 | pickup |\n",
    "| 5 | dropoff |\n",
    "\n",
    "### 5.3 Training Approach\n",
    "\n",
    "Behavioral cloning is supervised learning:\n",
    "\n",
    "1. Extract `(observation, expert_action)` pairs from demonstrations.\n",
    "2. Train a neural network classifier.\n",
    "3. Use cross-entropy loss between predicted action logits and expert actions.\n",
    "4. Run the trained model in complete episodes.\n",
    "\n",
    "### 5.4 Improving Beyond the Baseline\n",
    "\n",
    "The baseline below is intentionally simple. Better solutions may come from better input representation, a model that matches the structure of the task, stronger training, and careful analysis of failed episodes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "242d91d8",
   "metadata": {
    "id": "242d91d8"
   },
   "source": [
    "## 6. Submission\n",
    "\n",
    "### 6.1 What to Submit\n",
    "\n",
    "Submit a notebook that produces a file named `predictions.zip` containing:\n",
    "\n",
    "1. `predictions.jsonl` — predicted action sequences for all test scenarios.\n",
    "\n",
    "### 6.2 Prediction Format\n",
    "\n",
    "Each line in `predictions.jsonl` should be one JSON object:\n",
    "\n",
    "```json\n",
    "{\"layout_id\": \"test_0000\", \"episode_seed\": 300000, \"actions\": [1, 1, 2, 4, 0, 5]}\n",
    "```\n",
    "\n",
    "**Fields:**\n",
    "\n",
    "- `layout_id`: scenario layout identifier.\n",
    "- `episode_seed`: scenario seed.\n",
    "- `actions`: list of action IDs, each integer from `0` to `5`.\n",
    "\n",
    "### 6.3 How Evaluation Works\n",
    "\n",
    "1. The evaluator reads your predicted actions.\n",
    "2. For each test scenario, it starts from the provided scenario state.\n",
    "3. It replays your actions step by step.\n",
    "4. Success means the package is delivered to the destination.\n",
    "\n",
    "### 6.4 Constraints\n",
    "\n",
    "- Use the provided demonstrations for training.\n",
    "- Do not use expert action labels for validation or test scenarios.\n",
    "- Do not generate additional expert trajectories with search, planning, or another expert model.\n",
    "- Your final prediction process should be deterministic.\n",
    "- Your submitted notebook should generate `predictions.zip` from scratch.\n",
    "- Rule-based or hard-coded solutions may be reviewed by the Scientific Committee.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fd0fd7a",
   "metadata": {
    "id": "7fd0fd7a"
   },
   "source": [
    "## 7. Scoring\n",
    "\n",
    "### 7.1 Evaluation Metric\n",
    "\n",
    "**Success Rate (SR):**\n",
    "\n",
    "```text\n",
    "SR = (# successful delivery episodes) / (# total episodes)\n",
    "```\n",
    "\n",
    "An episode is successful if the package is delivered to the destination within the step limit.\n",
    "\n",
    "### 7.2 Diagnostics\n",
    "\n",
    "The notebook also reports:\n",
    "\n",
    "- `avg_steps`: average number of steps used per episode.\n",
    "- `avg_invalid_pickup_or_dropoff`: average number of invalid pickup/dropoff attempts.\n",
    "\n",
    "These diagnostics are not a replacement for success rate, but they help debug model behavior.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d546ff67",
   "metadata": {
    "id": "d546ff67"
   },
   "source": [
    "## 8. Baseline & Training\n",
    "\n",
    "Below is a complete baseline implementation using a simple MLP.\n",
    "\n",
    "**Baseline Key Limitations:**\n",
    "\n",
    "- The grid is flattened, so spatial structure is mostly lost.\n",
    "- Rare actions such as `pickup` and `dropoff` are harder to learn.\n",
    "- Action masking is used only during inference, not during training.\n",
    "- The architecture is small and intended only as a starting point.\n",
    "\n",
    "**Your task:** improve the model and training procedure to achieve better episode success.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d0f1d6b",
   "metadata": {
    "id": "2d0f1d6b"
   },
   "source": [
    "### 8.1 Create Supervised Training Samples\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fcbb6de5",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fcbb6de5",
    "outputId": "65984f15-7fa3-4b60-84ec-a2c2ee859db7"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Created dataset\n",
      "  state-action samples: 5327\n",
      "  feature dimension: 397\n",
      "  first action: 1 north\n",
      "  action counts: {'north': 1148, 'east': 1120, 'pickup': 400, 'south': 1066, 'west': 1193, 'dropoff': 400}\n"
     ]
    }
   ],
   "source": [
    "def flatten_observation(obs):\n",
    "    \"\"\"Flatten one observation into a feature vector.\"\"\"\n",
    "    return np.concatenate([\n",
    "        obs[\"grid\"].astype(np.float32).reshape(-1),\n",
    "        obs[\"vector\"].astype(np.float32),\n",
    "    ])\n",
    "\n",
    "\n",
    "class DeliveryDemoDataset(Dataset):\n",
    "    \"\"\"Store demonstration steps as supervised examples.\"\"\"\n",
    "\n",
    "    def __init__(self, trajectories):\n",
    "        \"\"\"Collect all observation-action pairs.\"\"\"\n",
    "        self.samples = [\n",
    "            (obs, int(action))\n",
    "            for trajectory in trajectories\n",
    "            for obs, action in zip(trajectory[\"observations\"], trajectory[\"actions\"], strict=True)\n",
    "        ]\n",
    "\n",
    "    def __len__(self):\n",
    "        \"\"\"Return the number of supervised examples.\"\"\"\n",
    "        return len(self.samples)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        \"\"\"Return one feature vector and action label.\"\"\"\n",
    "        obs, action = self.samples[idx]\n",
    "        return (\n",
    "            torch.tensor(flatten_observation(obs), dtype=torch.float32),\n",
    "            torch.tensor(action, dtype=torch.long),\n",
    "        )\n",
    "\n",
    "\n",
    "train_dataset = DeliveryDemoDataset(train_trajectories)\n",
    "train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)\n",
    "\n",
    "x0, y0 = train_dataset[0]\n",
    "action_counts = Counter(int(train_dataset[i][1]) for i in range(len(train_dataset)))\n",
    "print(\"Created dataset\")\n",
    "print(\"  state-action samples:\", len(train_dataset))\n",
    "print(\"  feature dimension:\", x0.numel())\n",
    "print(\"  first action:\", int(y0), ACTION_NAMES[int(y0)])\n",
    "print(\"  action counts:\", {ACTION_NAMES[k]: v for k, v in action_counts.items()})\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23a688a5",
   "metadata": {
    "id": "23a688a5"
   },
   "source": [
    "### 8.2 Define Action Model\n",
    "\n",
    "This baseline uses a small MLP. Stronger solutions should preserve the `8 x 8` spatial structure.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddb5a11c",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ddb5a11c",
    "outputId": "bb6b4fa6-561b-4fb4-cef2-5ea2031797a6"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "SimpleMLPActionModel(\n",
      "  (net): Sequential(\n",
      "    (0): Linear(in_features=397, out_features=128, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=128, out_features=128, bias=True)\n",
      "    (3): ReLU()\n",
      "    (4): Linear(in_features=128, out_features=6, bias=True)\n",
      "  )\n",
      ")\n",
      "parameters: 68230\n"
     ]
    }
   ],
   "source": [
    "class SimpleMLPActionModel(nn.Module):\n",
    "    \"\"\"Predict the next action from flattened observation features.\"\"\"\n",
    "\n",
    "    def __init__(self, input_dim, hidden_dim=128, n_actions=6):\n",
    "        \"\"\"Create a two-hidden-layer MLP.\"\"\"\n",
    "        super().__init__()\n",
    "        self.net = nn.Sequential(\n",
    "            nn.Linear(input_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, n_actions),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"Return action logits.\"\"\"\n",
    "        return self.net(x)\n",
    "\n",
    "\n",
    "model = SimpleMLPActionModel(input_dim=x0.numel()).to(DEVICE)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "print(model)\n",
    "print(\"parameters:\", sum(p.numel() for p in model.parameters()))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "996d499b",
   "metadata": {
    "id": "996d499b"
   },
   "source": [
    "### 8.3 Train the Action Model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec584450",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 174,
     "referenced_widgets": [
      "59dbaeda1223489c8111b1453a91fe0b",
      "8dd32ccd43a74764994ec88ba88c1644",
      "13f56156bd7b4d07b877c8144b275c5e",
      "9aa9ff04bede4043842f8c05dbd2286a",
      "cbf81fe3aa194e9b9476ed27f8e0cd31",
      "4b7b11fbe9114eb5a67e19f9f49b7c2b",
      "a9215a078b2443d88a903639fd5e5d6b",
      "4978e5e0a2e04a7aaa121718963f3c18",
      "4d26c0e03e2e4f8c8b32284a779691c2",
      "b2d542c8ca2547faaf793efb9099a181",
      "1da536984fb546f9857f5f2556be1dfc"
     ]
    },
    "id": "ec584450",
    "outputId": "fa77f116-376f-484a-d945-bd7d98796bcd"
   },
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "  0%|          | 0/30 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "59dbaeda1223489c8111b1453a91fe0b"
      }
     },
     "metadata": {}
    },
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "epoch 01 | loss 1.6379 | train action acc 0.542\n",
      "epoch 05 | loss 0.5841 | train action acc 0.846\n",
      "epoch 10 | loss 0.3724 | train action acc 0.897\n",
      "epoch 15 | loss 0.2537 | train action acc 0.933\n",
      "epoch 20 | loss 0.1915 | train action acc 0.967\n",
      "epoch 25 | loss 0.1368 | train action acc 0.965\n",
      "epoch 30 | loss 0.0942 | train action acc 0.965\n"
     ]
    }
   ],
   "source": [
    "@torch.no_grad()\n",
    "def train_action_accuracy():\n",
    "    \"\"\"Measure action accuracy on the training demonstrations.\"\"\"\n",
    "    model.eval()\n",
    "    correct = total = 0\n",
    "    for x, y in DataLoader(train_dataset, batch_size=1024):\n",
    "        pred = model(x.to(DEVICE)).argmax(dim=1).cpu()\n",
    "        correct += int((pred == y).sum())\n",
    "        total += int(y.numel())\n",
    "    return correct / total\n",
    "\n",
    "\n",
    "EPOCHS = 30\n",
    "for epoch in tqdm(range(1, EPOCHS + 1)):\n",
    "    model.train()\n",
    "    total_loss = total_examples = 0\n",
    "\n",
    "    for x, y in train_loader:\n",
    "        x, y = x.to(DEVICE), y.to(DEVICE)\n",
    "        loss = criterion(model(x), y)\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        total_loss += float(loss.item()) * len(y)\n",
    "        total_examples += len(y)\n",
    "\n",
    "    if epoch == 1 or epoch % 5 == 0 or epoch == EPOCHS:\n",
    "        print(f\"epoch {epoch:02d} | loss {total_loss / total_examples:.4f} | train action acc {train_action_accuracy():.3f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f705628b",
   "metadata": {
    "id": "f705628b"
   },
   "source": [
    "### 8.4 Evaluation Functions\n",
    "\n",
    "Action accuracy is useful, but the main check is complete-episode success. A model can predict many individual actions correctly and still fail after one early mistake.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b7829c0",
   "metadata": {
    "id": "3b7829c0"
   },
   "outputs": [],
   "source": [
    "@torch.no_grad()\n",
    "def model_action(obs):\n",
    "    \"\"\"Choose the highest-logit action for one observation.\"\"\"\n",
    "    model.eval()\n",
    "    x = torch.tensor(flatten_observation(obs), dtype=torch.float32, device=DEVICE).unsqueeze(0)\n",
    "    logits = model(x)\n",
    "    return int(logits.argmax(dim=1).item())\n",
    "\n",
    "\n",
    "def run_episode(scenario, action_fn, max_steps=MAX_STEPS, render=False):\n",
    "    \"\"\"Run an action model on one scenario.\"\"\"\n",
    "    simulator = DeliverySimulator8x8()\n",
    "    simulator.reset(scenario)\n",
    "    frames, actions = [], []\n",
    "    invalid_pickup_or_dropoff = 0\n",
    "    done = False\n",
    "\n",
    "    if render:\n",
    "        frames.append(simulator.render())\n",
    "\n",
    "    for _ in range(max_steps):\n",
    "        action = int(action_fn(simulator.observation()))\n",
    "        _, done, timed_out, info = simulator.step(action)\n",
    "        actions.append(action)\n",
    "        invalid_pickup_or_dropoff += int(info[\"invalid_pickup_or_dropoff\"])\n",
    "        if render:\n",
    "            frames.append(simulator.render())\n",
    "        if done or timed_out:\n",
    "            break\n",
    "\n",
    "    return {\n",
    "        \"success\": done,\n",
    "        \"steps\": len(actions),\n",
    "        \"invalid_pickup_or_dropoff\": invalid_pickup_or_dropoff,\n",
    "        \"actions\": actions,\n",
    "        \"frames\": frames,\n",
    "    }\n",
    "\n",
    "\n",
    "def evaluate_action_model(scenarios, action_fn, limit=None):\n",
    "    \"\"\"Evaluate complete-episode success on a scenario list.\"\"\"\n",
    "    results = [run_episode(s, action_fn) for s in tqdm(scenarios[:limit])]\n",
    "    return {\n",
    "        \"success_rate\": float(np.mean([r[\"success\"] for r in results])),\n",
    "        \"avg_steps\": float(np.mean([r[\"steps\"] for r in results])),\n",
    "        \"avg_invalid_pickup_or_dropoff\": float(np.mean([r[\"invalid_pickup_or_dropoff\"] for r in results])),\n",
    "        \"results\": results,\n",
    "    }\n",
    "\n",
    "\n",
    "rng = np.random.default_rng(SEED)\n",
    "\n",
    "\n",
    "def random_action_model(obs):\n",
    "    \"\"\"Sample a random action.\"\"\"\n",
    "    return int(rng.integers(6))\n",
    "\n",
    "\n",
    "def mlp_action_model(obs):\n",
    "    \"\"\"Use the trained MLP action model.\"\"\"\n",
    "    return model_action(obs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebbbdef8",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 117,
     "referenced_widgets": [
      "b9238557e0794f77b21d6b1178aee65b",
      "fe37839d91f14f92aa862c19f6de8280",
      "3ce3f49a88304f76aec169899a95800b",
      "ed4dbe2e6c3a4b1abb4521f028e37c1e",
      "1b1ecf1906974616aec32aa4bddf8f60",
      "08c38dcb5c214cf6978726264300a585",
      "11ddaf22309b42258cbea56df87e6582",
      "9732b3af3b0e4fa6ba804713ace4f2f1",
      "360c0157cc6f4b4e9e3d266c1ebd7a85",
      "38601771c6ec4ae2854c25e20f656358",
      "060c9e1519354ef6a2392c26165d828f",
      "5b2456238c0943838f645b24f78b4fb0",
      "1193102cb17d4362a660e1829485c6b6",
      "901a42e725b746b7936574e9e3472c5a",
      "66865a8a9d444aff96234a17af14e401",
      "4086a7f416094d47801a1be5d0f16c8f",
      "797483c087824bceb4de34cfb69a8190",
      "c53cf91787134a1181d8c55a73d3a028",
      "ae9dafcb19714503aca9f96ff520bc20",
      "802a0f77d4da4ce8b1402c05f11f9913",
      "9fabe73aabb24083b3461ebd2eafbb44",
      "6bc62fbda0d745e69e37394017e02f0c"
     ]
    },
    "id": "ebbbdef8",
    "outputId": "8fcdfc62-ff43-4457-cb15-2bed9dda2030"
   },
   "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": "b9238557e0794f77b21d6b1178aee65b"
      }
     },
     "metadata": {}
    },
    {
     "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": "5b2456238c0943838f645b24f78b4fb0"
      }
     },
     "metadata": {}
    },
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "random {'success_rate': 0.04, 'avg_steps': 118.86, 'avg_invalid_pickup_or_dropoff': 38.56}\n",
      "MLP {'success_rate': 0.19, 'avg_steps': 99.58, 'avg_invalid_pickup_or_dropoff': 56.16}\n"
     ]
    }
   ],
   "source": [
    "EVAL_LIMIT = 100  # set to None for all validation scenarios\n",
    "\n",
    "random_eval = evaluate_action_model(valid_scenarios, random_action_model, limit=EVAL_LIMIT)\n",
    "mlp_eval = evaluate_action_model(valid_scenarios, mlp_action_model, limit=EVAL_LIMIT)\n",
    "\n",
    "for name, metrics in [(\"random\", random_eval), (\"MLP\", mlp_eval)]:\n",
    "    print(name, {k: v for k, v in metrics.items() if k != \"results\"})\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38cff46a",
   "metadata": {
    "id": "38cff46a"
   },
   "source": [
    "### 8.5 Inspect One Validation Episode\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d433972",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 955
    },
    "id": "7d433972",
    "outputId": "ac85e0e3-dca7-4823-a1d5-8442fbabb9ea"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "success: True\n",
      "steps: 18\n",
      "invalid pickup/dropoff: 0\n",
      "actions: ['north', 'north', 'west', 'north', 'west', 'north', 'north', 'west', 'west', 'west', 'pickup', 'south', 'south', 'south', 'west', 'south', 'south', 'dropoff']\n",
      "initial frame:\n",
      " #  D  C  .  B  .  .  .\n",
      " .  .  .  .  .  #  #  #\n",
      " .  .  #  .  .  .  #  .\n",
      " .  .  .  .  .  .  .  .\n",
      " .  #  .  .  .  .  .  .\n",
      " F  .  .  .  .  .  T  .\n",
      " .  A  #  .  .  .  E  .\n",
      " .  .  .  .  .  .  .  .\n",
      "package=D, destination=F\n",
      "final frame:\n",
      " #  D  C  .  B  .  .  .\n",
      " .  .  .  .  .  #  #  #\n",
      " .  .  #  .  .  .  #  .\n",
      " .  .  .  .  .  .  .  .\n",
      " .  #  .  .  .  .  .  .\n",
      " T  .  .  .  .  .  .  .\n",
      " .  A  #  .  .  .  E  .\n",
      " .  .  .  .  .  .  .  .\n",
      "package=F, destination=F\n",
      "animated rollout:\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "image/gif": "R0lGODlhwAHsAYcAAP3+///89vz8/P/7+/j7//j6/Pb8/fD7/Or68Pz5//r1//758f726fP4/uj57v705PHx8v3pyP3px+fv/uLo8P3nw/znwvzlvfzi4vzd3fza2vzX1/vV1erV/fvQ0PrGxvrDw/nBYvi2SPe2R/ixsfirq/akG/WiFvWhFPWgEPWeC9r15NX04Nrn/eDm7tnm/d/l7d7k7NTk/d3j69zi69vh6tvh6c/h/dnf59je59fd5tbc5M/g/c3f/dXb5NTa49PZ4tHY4NHX4NDW38/V3svV4c7U3c3U3czT3MzS28vR2tOo+8Ht9Mnx2Mjw18bw1cTw1MHv0rTrycrd/crQ2cnP2cfN1sbM1sXL1cTK1MPK08LI0sHH0cTGyr7Fz73Dzbi+yLa9x7W8xrS7xbC2wa7qxKfov43hrHjaw6+1wK60v620vquyvamvuqivum7ZlmHWjFnUhjPKayjHYiXGYKeuuaWrt6SrtqKptKCmsp+msZyirpuirZqhrJmgrJifq3ao+W6j+CLFXga21PaTk/WLi/SCgvR/f7t7+fN4ePNxcfJiYvBVVahV9/BLS+9ISO9GRu9ERJedqZadqZWcqJOZpZKYpZCXo4+Woo6VooqRnomPnIiPm4eOm4SLmISLl4OKl4GIlX+Gk2Ga+F6Y+EaJ9zuC9nd+jHZ9i3V8inR7iXJ5h3F5hnF4hnB3hW92hG10gmdufGVse2JpeGFod15mdV5ldF9kbl1kc1xjclticVpicV1hbFlhcFlgb1deblRbalJZaVFZaFBYZ1BXZ09WZk1UZExUY0tTY0tSYkpRYUlQYEhQYEdPX0ZOXkZNXUVMXERLXENLW0JKWkFJWUFIWUBHWD9HVz1FVTNBVThAUTg/UDc+TzY+TjU9TjM7TDM6SzI5Sy01RiszRCgwQScvQSYuQCUtPyUsPiQrPSMrPSIqPCEpOyAoOiAnOh8nORsjNhsiNRoiNBggMxcfMhYeMRYeMBUdLxQcLxEZLBEYJwAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQALQAAACwAAAAAwAHsAQAI/wCLCBxIsKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPDbCBDihxJsqTJkyiLFFjJsqXLlzBjypypcqbNmzhj1szJs6dOn0CDFtgptKhNokaTvkSqtOlQlFCjSj3J1GnSqlaLYs0adCtXn16/8gwrFifZskenql2bEq3Rs25/xu06l25dsHfx5h3Ltq/fbHD1CR5MuLBhwznh7h26OHFjs49vKt47OW+Rv5inhj3MuXPno5FBh5ZZ+W7puqfnpo57ObNrqjM9y54tmOZo0rfl5na52m1vtL/Ltn5NXCRW2shn697NMrhY51+hc5WelbrV4cWLVz2sorv37+DDh/8/DBOuoPPo06tfv94x85ZwTcmfT7++ffvu36+07pR/U+zZvcaUYeIVaKB4iPF2E3sMNsieZPo1d9N9FFZ4H4QRMpahf0oBGGBmAxJ24IgkFraUTQ6mqKJoEYZl4Yswsqgfh1dl+NSHxCFVGIk8HmgifDOpKKSDtm04E4xIWlhkizbS+BaOOba0Y49UIkgYkDENqSWDuBkZU5JgUtglk162CKWAUg5W5ZrjDYblS1vG2V55TX4Z5p31Lfeek1o1eaZrRInI5qAqXCkhTHImep6ezGGF56PyMbobn0JR2tWfILIkKKGDGqqhS4qGSmeZLUFq6qhkpjojppjttCmna3r/WlWoiqI6I0ymQmrrnnVuyOpfrqoJK5uyIkqrnLs2imuueCY7aa9m/tpXsIINS6yb+xl77JbO5lYVs82eSCqvvkrLFrX6UBlABRZEEAKnxcI55BssNBGFHKKKqypLYBLAww0tAHKqvreO26i552oqLI8LdHeCBe92iu2nLQ0JhxNzCALHE/kqaHABYDYgHykTDOzxvsqWi7BmClfbY8PdjSABofGCKmQUcaBnBh21EkyuSyHPV7KuPqeM8qQrq4UulTCrkAIDNE88q5AOZLxtt7d9m6TIpgQiMNEnF3y0t0mzvNKrIzaNwgNR15atvCoiYPWxWI+mNZL+ygDAFCa//yn233uWLdXSL3s3wgVt63OozSo2kfN5ZXTs98+lbj0y14/WHZqlQHEOluBREc5wdyZEIELii1cs5BtQZPyGFJKnTjm/lptSygt9y2404AeD3tbZC5O4rgUSRCyx2xSzpOUZKzghBb49hz37Sv3y0EMPo+T+9thZ++k7bMC7bC2VNau+rZaaR3Y3uEmm/5jnPcHP1/cmiT4+j+Urfz76RT/7Evthcl9j5JefVdGvJPa734jyt5L98U96u6MdAJEkwMUQEDIqO6BxWpYuBeJPatpyYIoqSJllTTBG/fMWtAyowQ2Gr4MeXCAI4SZCIqWwe/87IQoh6D/u2a2FI0lgDP+thLyp1dCGPFRhDnWopBvabYWBA2JIhDhE8DCwAEccoRM3Z0ImimmL6oNi76QIGA5W0UczZFwWHwTG93XRi/hp4wDFiDQylvGFZzTQFdfYIBJa5o1wpI8fTUNHstmRinksVBrNx0f1DBI1gAxkpORowUJmzY53LADaEtmdPTZyTknEIdAkGcdQPvFjhiQjIvPoyU+m55GqiaQkYckaS/7wkGbkpBUXqT9XooeWvpFlIIEJHFtuDpOrPGMrfSkIYgpHmHB05nOMqT5k5lKX3lmmL6UZHWh6kZvToeb7rHlNXXoqeb10paSUuERSmmKdouRdHVWZJvGZc2LobCAz4Xn/ynaSkp9cROUlcclBGCbyR9ujIR/HJE/quZOh0+shC6Woo03GEKEJVegRl9RQhw4TohEM6Twp+pIpVRGjGdWoA2UU0cp9k6MtjWcU6ekSAg0xQZML4UpZKtJR6hBDPgxotGhaU5uOjzxy3ClQO+pTcBUwpv2cKBCPk5yqIpWSJRRoVKEqVKm20CtWDStMeypTsm7VrMckqEzCmhyeSpSrYdRqV2dKUpywlTNPRWtcg7pXpqaVqH7tK1zdKFfBjrGufCVsYudYWMV6VYMXXOpgGbvYSjZ2gB7JrGY3y9nOevazoA2taEdrEXFSNrCOpetUkUnOymbVtX/M4GoP2VrU/552spYdKkVZq1bb5ta3r33sAT0E2driNrjHja1uZ6tK4+o1tc+97WGZu9veJpeQl/2tar/KW8BeF5LZRe50uUtb60ZXu+cV70ipy96vmha9b02vZbpbXe/KF7uwxa9w6Ufc4To3vgBmJ3DnW97mmjfAZUXwWddLXgPbV8FzvS94l9vg+iJ2wPr9bixlW+H2Qva96hWwhllDXw8PF8TKxfCE9/u9/vL3vyKW8Ibzi5oSd9i94U3xiIPJ4eIW+MI7LmaOMzxeHzsYyDKu5ZBXvF0jW3iqKCYyhA3LYCebmL9RZnKSeUxhK9/4w0uesYrF3GT//hjKYVYyjclcZDMfGf/Na1bzmOVc5hefGcdx5vKc9VznFtsYzHkWcqCf2WM3PxnPexZ0ogndZUNfucVZZvOUoVtlR3/5xGnm85YV3WffudjPB47xpKU7agv+2dKAXvQ0M83pNtv5zYgOMqNV3c1Cv/rQqZb1qge9axZ7+tRYZvWsdV3rRt/60Z6ONJ03PWxXgxrWuWZ2r4kdTls/G9eY5nWxaV1tY18b2aCLrFtFTe4EpxLbx461tLdN7ep4D9qozja33S3saTv713eOdqlDbO5+3xLe6dZ3uRc88AhXOuDxDra2uz3v67wb3d9W9751vG6GdzrcwIZ0vdldcXp7G98A1/jCPd7w/jwc3IL/+3SyN27xjjvc2iCH+MpH/nKamxzmGM+3vNtd85L/5+SXRrjCfd4hZWv64BH3ssD9bfCCU/ncKC+bysNt9FZPXMpQD3rSd+7ym9v85zhPecY9Tdqym/3saE+72tfOds5WXTgwZvrTB/pgp1M660snuNzHGeq9kxrvXL+6lpE+c6LXKOxSf7u9CU91lpP84ilXPMcZH3nH9xzyibe8133d+K8XHfFJE/dYBa+auOv99H9FMumXTfnMe/7wH++84d8C9Lw33e+m7jvq5/5v1dv973T3Pe753Xs4z75PoF+Z6EG6et+Y/va753vdh0/x1ode8i23vvKx//h7y57nm8f8//U1D/bYV/71tE8+wpYPUN6n3vjgLz/nz3/8StU+8L+HL+CHHv/Pm9/19WcX/zd+6Id8A7h95Od/8weA/Qd7C0iAAdg598d/XSd/4oeABWh/6mcu7AdO3ad968d9l+d99NeA6XeAIZiADniBKZiBAviAGBiBeoGCHCiC4UeCDFiBCsiCNaiCJwiDLSiD8TOBIieEY0GEhWeCBgiEPeiCEriB0tKBWFV9+1eESqiBNBiFNmiBOAiBV/iCPKiFPriEYfgrUmhK0Pd+Epd/xKeGtud+cCh9whd9wFd8a0h9WBd88KeDK9iFMfiFT5iFZriFO+iHQQiIM8iEYuiEiViGrP9yhjnVfMDxfHFYh26If3g4eFWYhHz4g46IKZCoO5IId7qXhpWYe9NHh/qnh3eoim1YTaV4iq8oh3s4iou3id/XiWRoiE1ohHkFgr2IiEMIhYM4hlioiMXIiMMoiI9IiH0IjIvoixjEjKDojJ7Ii9EojEdIjM1ojGCIjckojZIFjt2ojNtIjX8Siilli9FBiXeXiaUXi+/oigSWiqY4j5dIgeyYfbhYgrp4jJ+Yjta4i9AYjtr4i/2Yg/v4gQnphf/4jQVZjuI4bqz4hvgoi/U4h/doibBojxiZh3ZokRx5kbTYihu5iiGJifQIkvlohY3SdjAZkzI5kzRZkzbJEAP/CZAPGYgTOXpsSIXwyHo/yZIfqYlBeXRDaZQrqZQnOYsj+ZQo2ZRAuZSSlpRVeZRWZ5VCiZXNtpAj6JU3CJZcKJaFSJbPqJVIyZW3qJaTh5ZZyZb8CJcMKZdf6ZZdaZdrSZVbqZdpyZdv6Zd3SZdhiZdtKZhjSZhxCZh5KZVESZJQ6ZRRWZRXqZiFSZmJyZhMKZl7iZmTyZmbqZl96ZmhCZp/KZqlSZqBaZlzqZp1aZhliZiraZqpKZuLiZq16ZiRiZuQuZtTSZuV6ZuXaZu/KZzBqZu9SZyxiZytyZqD6Zpn6ZzXaJbRCZvLCZzJaZyN+ZjHiZ2ZyZ2dqZzNyZyH/wmdBEmd4Wmd1Qme4ymer0meOimd5emeEGme64me56me7cmez6mf0ymfPHmQ09iTzEef+Wmf9Ymf+2mgBYqg/cmf8emg70mgCcqgD6qgE+qdn4mho6mhp8mhs0mhEeqfjbiTIwqfIQqh8ymiyyig7eeht6md2ZmbMNqdM/qdLjqcN1qcNZqhO7qhPdqhP/qhOXqdQfqiMnqkvBmjSUqjSLqdRYqjT6qjTaqkTjqlTLqkNhqlRGqlWcqlPOqlPgqmQCqmQqql6TmkZ2qm94mma6qmB8qmb+qmCwqncyqnF2qnDWqheQqiKYqi/0miKwqg42iifaqnFcqnf0qoiSqhe/9Kp3dKpkaKpV8qqWFKqWNqqWUKqVCqqVKKqZFapZ66qaHaqaBaqlR6qldqqqmKql06qlvqqmnKqa+qqq1Kq5Nqq5WKq5eqq5kKq20qq7Hqq3EKrL8qrHVKrMNqrI+qrI2Kp4fqqM2KrMfKrM/qrCdqqNeKqCXKqNUqrcvKq5/KqrcqrrlKrrtqrr0KrqKqrqSKruGKGjcZr/I6r/Rar/bqEEiYi4q6rSp6jizqgdfhjtZaqNoaqIDqrwF5JuqYT9yardDardRaKQLrrdEasQT7sA47QBNrsYvarwjpsQGasFCysCSbkxc7sB2bkvrYsCdLsRDLrrNqGhsLs8FKs8X/arPJmpG1yLIpi60ty7H8qrIuua8GS7QIe7AfK7ScaLRJ67M9W7BHG5HV6I1Pi7E/i7PTqrMmCbVNy7Uhi7RfK7UCSbVB67Rl67WD2pB/CLZpC7Jt66dnW5Ii6bIZS7dX667rKrPyiLJxy7dFy7N9i4oaibYUCbd/67aF25JLC7iHa7hRy7iPW5EqabaNS7mR67hdK7eTS7g+ibidi7lhq7aHyLaJy7kD6rmnq7T6CrmZ67eXa7mtK7g7i7ot6rqxC7SV25GDa7VVa7uhS7sA2x8zi7ftuqrGW6vEWx3De7zjyrzl6rznWmN7a7e9S72Bi7uvq7uzC7pvC7u/y72l/6u5Kwu8U5i8NWu+N6u3Hsm714u134q+Oau+u+u73Wu6tWu9uSu+Q8u63+u99cu++aux04u9t+u+FWvALyu/2+u/4Uu/DYy/2au/i0u+aGi/wRu/0EuK6+vAn8vAHWzB5Su9GwzBBQy/WWvC7yvC80vC/QvCFQzAESzAI0zALQzDJZzB7xqPM4zAdUvD/8vBqau4q0vBkci/P8zCR0wZy4u8OJy3TVy8TKzDK+zDD0zFH2zDNSzDU8zDd/vEMevF56vCC+zCRUzEomjEVay1c2vFQUzGZ2zG6yi6wUi6VwzE98vGd6zGm4vFSczF1YvHF9whS9y8UUzIhvy8hex8A//sx+2LwgfsyAksxlvLx2kMyT3MyAEsu5Nsx4GcwokcvZ+swVtsyV0cyjl8yKBMYotMyn+MyTGMxEdxr7I8y7Rcy7b8WSbbyqzcyGCcvr2MwabsxMEMxaicrrucyYAcwsP8xcscxs3sy88MzMV8yog8zcJszcRczdqcyttszL98wt/sydjMzOPszOUMzecszd1Mzdzczt6cpYMQz/I8z/Rcz/V8w9EMzvkszut8zaNpzwAd0Pbcx8f8ysn8wpyszJsp0Azd0JUczo8M0ZH8yZ8R0ZPZ0Bgt0HUMyxt90GVMlW1VyluZ0SQN0G1MyR3tyvg8rmyly5pY0jB9z51s0en/rM81/a13pTjITIUx3dPxnMcFvdL9nM2XmtPIk8Xw5dNKPdMTfdM0PdRbatT49NCSptQ+zdSXHNRI7dFvXFRSfdQpLWVW3dNYLdJQbc5nvaZfjVJAPXhjHdNl7dL7/NTuXJtrjVMnTWokbQBM0NdosNQKndbqXNf+XJp3fVVtXdUZfQBvPQhxzctz3dSCXaCHjdePXbQkzdhvfdkGrdJb7dlvW9mIHdhWl9mNzdlCTdhE/c57ORu80AVdIACwfQtVFdZundF83ddWjdqfrdUELdEnmhwQ0NJ5ndSLfdqkzdqTzc+qPZdVNdzEzduDatqbndzsrNzNjdZv+dx3Vdzq/0XdYy3dVO3Ukp3dzcnd0W3dk9fYJS3eth3ZWQ3cKYreYpXYrMfeJO3e3g3a473c/UnfVrXfYo3fGK3f9u3f5Y3dgQngtX3gpU3gDq3eq33dFF7YCy7ao/3RBgfhEY7QHC3g8i3XW4nhGd7VG87hGi3h5Izg8Q3f803ibG3iVIbiKe7hXB3HcMyw/gbjU23j1UfjAW3gQq7i2q3gecnjYO3jAw7kMq3kIQ7Z5N3irY3k733fTN7kGu7GOA6+VR6aPN7fD37l8zzkTu7iIs7ihfrlXR7mYv7TRI7OaH7m5n2gJP7bit3mbl7mUW7Wc27TGyravX3beO7Ybz7YRm7hFf+uo4ed2l056Hme5SgN4mYO5WG61p2NdYPu4Ic+4Yje6Z0q1TuN6Xiu6Ym+4n3O3Oma05T+lm0u6Xsu55tu6sac3oyel1e+5rFe5KWu68Ic0rC+mEAO5rkO56dO19hd0Qlemyhu56++6sNu6LtO7GWK37Xu6bIe7dBu7bzO6dx+7dou7dju58We7N+e7d2+7d5+7uBe7uL+7O0e7qgO78Yu7+Su7uae7viO7vq+7vb+7uwe7/8+7wFf7/nO7wV/7/uO8Aaf8P7e7wDv8AIP8QR/Hbdc8RZ/8Rif8SXLjVNrjtUu8VIe587+HIMs8qH+5Cc/6Smvyjvs28JO7yE/7jH/L8pjHOmkPvAzD/N8TvOb/OE3D/I7r/O/3o6rjPKXbvQff/ANr7xFr/JH7/RJz/B3GglUX/VWf/VYj/WJUfIyH/RQ2ghgH/ZiP/ZkT/ZRv/D3mfVqv/ZZLxlc7+4Pn5xlP/d0X/bMbvKvy/Z6v/dp0fTNvvKhWfeCP/gvj/N9uveIz/Y08fZCP/KVOfiQX/e43viHm/iWr/akwfiGP/RxGfmeP/eujvcIefmkr/XloflAz/kM+fmsb/ZkDul/V/qyT/U6gfpKH/d12fq6D/Y/f/vROfvAf/p+L/qBLmm7f/yvL+OUBvyzL/wtj/TFz3rHv/vJv+UGx/yy7/yjDP13/29106/71a/jC4b9pa/9NZ/Qen5039/64b/xLnH5hTAAjMD85t/zNy7+Buf5CdAB/L8EyF/oAFFA4ECCBQ0OLHJQ4UKGDRkmNBhJ4kSKFSN9KFHI4kaOkQ4WyRZS5EiSJU2eRJkSokOWLVuudBlTJkGYM22+PNhI506ePRX0BBo06MebRXEaRbqwpsCOFh15WASi6VSPBkGmxJpV68mlSb129YoUbNiiXYUG/XlWbU+iZMmOdTuzK9WJhwhF0vCILsePW/3+VRk3LFzBLgkXZml27c60i9e2RVw2stG5e0lk2MAg0d6NfQF/Bn14stLRN0WXtprTcaMEHVwjWj00Nf9qmadpIzy4FxIHiYlIcLboGfTwrbZvFzB+OzltxY4bx5ZdcDnq6aUrU1X0O5IjDMArCiceHmX10eQnm4/cfPFz6GxnH08M/2jBvSUMTYTqfSJ48f1HokcMwMIEFEy9tVpzbYn2eIJMvoccdOg6/SasSjr/LvwPwoYIjItDtwxccMEGNXyPxBIHojBF/jAUz8O3TFTIxcFUC7HGEWEUSMavcktxwhVZJE7HpIQUC8cTBaoxyRtxJJIyHnv07kcgQzNSuippuhI3g5K08Ugms8zxSSg5k3JKwJqUDEw0TaORS+iWhHFNmyQck64yzfRLTrnARI5PEN1cDE4T9axNzDr/qboTT60IjYlRw/xsE1DHBCXR0fkIOpRMqxQNz9L41IR0S0ljo1RDTyM0NNOOEuU0MFBfzfLPUYUqFcJTN0xV1c42bZVKWK+89UFRZw3UyzhDpU/XqVjt1aRgSfu1SlmJdc/KaI2kU9ngeG32r2djRBbYSKmNDstrv4xI21W57ba4cKV9F0ly1arVwW+XVHddC9vNM150Yx13XgaNHdTffPlil1+s7iW4Un8FPqte+Ri2Nt2D92NW4WwoNhfgcwuAGChwPy44V3Vj1HhRf4/9OORqKxaX5IslUirlrDjW0mOdhw0Z2p3hXejih2xeeOWSfy7IZWGR/lehfDck2lWm/1meeiCIcSXZ4Ya0jTDq8YzWumqryUU1a1NbyvQlr7kC+2yzx5b0UqDFNnVtZ9u2FW979Z7YT7tLwjnMt/cevO/C4bvqb5EC7/Pw4xiHnG/EFc/QceUkfxzzy9WkfHHNmfucutCt87vzjUcvD/XzVE+v9M4jtxz02Kkronbbb8c9d9135713338HPnjhhye+eOOPRz555Zdnvnnnn4ceeNYDnH7A6gu8vsPsP9z+xdlJ/z718Fcfv/XyqT/f+vSxX1/79rl/33u6845/xvp3vH/I7u2fn/D+Df8f4vaHvwBmLn9FOqCTEpimAm6ugbJ7oOgWyKYJzmmA+qvgnjJYqP8NNuqCCIwg+EIovhGSr4TmOyH6Uqi+FbKvhe57IfxiKL+YzZB/NcTh3HKIrQ8q0IYE3GHTdDhEHnbwUUaUWxF/iMElgjCIVHvi0aIYtim6rYk+rCL9rsjALPqviwD8ogCR+KktUrCMFhxj2c6owTVysI0eTCPW3njEOSZRiEoMowHrSMY8OrCPEPyjBPeoxkCKsJAkPKQJE4nCRaqwkSx8pAsjCcNJyrCSNCTiHTUJxUxyEo+dlCIoqShKK17yhqTUoimBiEovshKMrhTjIOWoSibS0omw1KMtsYhLP/ISkL4UpC65CExDEhORxlQkMhmpTEcyE5LOlCQ0KSlNS1L/E5OfxOYmQ5lNT2pzlNzcpjdLac1TgvOb4kwlOVdpznGyM53ubCU8XynPWArTjPZEoyyXhk828tON/oSjPn0GUDoS1I7dRGg4E3rOhbYTnfF86DwjWk911rKit6RnLi+6y4z2sqO//GgwNzrMkBazpMc8aTJTusyVNrOlz3xpNGM6zZlWs6bXnKhGb1rOnHq0pyD9qUh3us6gmrSoKD2qSpPK0qW6tKkwfapMo0rTqdq0qjht6DuvytOsQrSrEv0qRYdq0bFidKtEDatOz0rWtZo1rT59K1DjKtS2crSuJL3rPUeq17Lada5G/StSA6vUwTK1sE49bGEosFjGNtax/4+FbGQlO1nKVtayl8VsZjW7Wc521rOfBW1oRTta0pbWtKdFbWpVu1rWtta1r4VtbGU7W9rW1ra3xW1udbtb3vbWt78FbnCFO1ziFte4x0VucpW7XOY217nPhW50pTtd6lbXutfFbna1u13udte73wVveMU7XvKW17znRW961bte9rbXve+Fb3zlO1/61te+98VvfvW7X/6uFx7C/W9/BTzgx4oCszsYhjWGsQMKIFjBDGZsgCtrYC9o4rMGniyGFythzXL4s/WQRjSuUQnMglga0vgEgVWMWw9P1hUpBgUrKPBiCsS4sS2OLI43q+MI37izPO7wYnHwjD1cFsgrRv9yajnBjW244RT5YMYPduEMaohhw6+oBjWssFhwIIECSfgGBbr85TD3eLFesAY4PEGBIARDGswYwpOZQYH/GgEZ1ECGEeisiml4Qw8UWAZjl9xkOaNZzRuuRSfkbOYrZ9kKhl5zm988BDpTYAje8AKkKUCEYlRDF++ggJSpbOVAMxoM1ngsGSB75CS3mrTt0AEXclFpWoyBAlXoxmLt0QcKTEIYi3WHCyjggnZQINjDLjajZUEGIKSDArj4AwUsIYtKV7oXlKAAJXZBgXqs+QrloIAOGAtrWVd62c3WdR027GPG7rrXwji3s6EtbWrDYwbQYAMF4k0BXUiCAnm4BwX/an3rXIub0TFYx2NVoQstOJbVrob4Z20hjDas2xwnloY4hF2PGVCABgk3trCJHXJkszvcmWjFPChwjo67gMEB/i86aOBxdFDgHj5YbDwcO/GKV1oHKFc5BeYh7Gqvm7Ec9/g6fp7ylbf85bO4xGKXrnJzzBwG9KDAxU+scYcz1gbmWGwqpPFnCiAhFrBorImlsYWIt520aQhGLSqtjhoMOw2LHbrHycFlL4NZzH0vs9EpoIxMKEEeFFDHzM3833TMnAY1P7zgGQt3uf+X8IYXPIc5nHcakOPyh098Y+2BjVks9vMUYMfMZ1APxNfdBXfv+mLVgAzIxmATvzC523X//9kdTCMGOGAHBeThAmBE+w7JWOw98NBrWyyWxqBoxYxhHH1Gv2MHWcAHBYjBBwpgYhXCF/Z/e+FvSfSi6P/NwWJ7//vgD9/62Bf88Blt8+VPwhbvz/72u/99eLigGZmgAPyjAGHgvj6wBwooPgo4PgpIPzP7AWxYg8fyg2Gwg9jbvQvsrFDQBm7YBAo4BmOggmSYhme4gg2zBWooBiFQvwRbsAZjQQgTPFQIB19IPSyQhmkoBpz7wEpDgmSghmQ4gvOjgDlbLA3kQA80BhmkwZmTsB2UPHg4wRRUwhq8wRysNCEYBzGYQhqwAmqghlYAtRAcwRIkwsUCsWiwBrJzrHtMILrcw8A3LK2HyzEAc8POsoUvoIAwoAY45EPjksNVo8P58ywwoIZliAYv6MNEVMRFZMRGdMRHhMRIlMRJpMRKtMRLxMRM1MRN5MRO9MRPBMVQFMVRJMVSNMVTRMVUVMVVZMVWdMVXhMVYlMVZpMVatMVbxMVc1MX6CggAIfkEAS0A/AAsDwATAHABxwGH/f7///z2/Pz8//v7+Pv/+Pr89vz98Pv86vrw/Pn/+vX//vnx/vbp8/j+6Pnu/vTk8fHy/enI/enH5+/+4ujw/efD/OfC/OW9/ODg/Nra/NfX+9XV6tX9+9DQ+sbG+sPD+cFi+LZI97ZH+LGx+Kur9qMZ9aEU9aAQ9Z4L2PXi2uf94Obu2eb93+Xt3uTs1OT93ePr3OLr2+Hq2+Hp2d/n2N7n193m1tzkz+H9z+D9zd/91dvk1Nrj09ni0djg0dfg0Nbfz9Xey9XhztTdzdTdzNPczNLby9Ha06j7we30yfHYyPDXxvDVxPDUwe/StOvJyt39ytDZyc/Zx83WxszWxcvVxMrUw8rTw8nSwcfRxMbKvsXPvcPNuL7Itr3HtbzGtLvFsLbBq+nCjeGsetyebtmWddfnr7XArrS/q7K9qa+6YNaLU9KBUtKBM8prKsdkKMdiJcZgp665pau3pKu2oqm0oKayn6axnKKum6KtmqGsmaCsmJ+rdqj5bqP4IsVeBrbU9pmZ9Y2N9YuL9IGBu3v583h483Fx8mJi8WFh8FVVqFX38EtL70hI70ZG70REl52plp2plZyok5mlkpilkJejj5aijpWii5KeiZCdiY+ciI+bh46bhIuYhIuXg4qXgYiVf4aTYZr4Xpj4T4/3PIL2O4L2d36Mdn2LdXyKdHuJcnmHcXmGcXiGcHeFb3aEbXSCZ258ZWx7Yml4YWh3XmZ1XmV0X2RuXWRzXGNyXWFsW2JxWmJxWWFwWWBvV15uVFtqUllpUVloUFhnUFdnT1ZmTVRkTFRjS1NjS1JiSlFhSVBgSFBgR09fRk5eRk1dRUxcREtcQ0tbQkpaQUlZQUhZQEdYP0dXPUVVM0FVOEBROD9QNz5PNj5ONT1ONDxNMztMMzpLMjlLLTVGKzNEKDBBJy9BJi5AJS0/JSw+JCs9Iys9Iio8ISk7ICg6ICc6Hyc5GyM2GyI1GiI0GCAzFx8yFh4xFh4wFR0vFBwvERksERgnAAAAAAAAAAAAAAAACP8A+QkcSLCgwYMIEypcyLChw4dkUjycSLGixYsYM2rcyLGjx48MTYDMuIbfG34lR6pcybKly5cwY8qsyGagmJk4QZbKybOnz59AgwodSrSo0aNIkypdyrSpxTY2nUqdSrVpiapYX5LKyrWrUIlew4odS7as2bNo06pdy7at27dw48qdS7eu3bt48+rdy7ev37+AAwseTLiw4cOIEytezLix48eQI0ueTLmy5cuYM2vezLmz58+gQ4seTbq06dOoU6tezbq169ewY8ueTbu27du4c+vezbu379/AgwsfTry48ePIkytfzry58+fQo0ufTr269evYs2vfzr279+/gw4v/H0++vPnz6NOrX8++vfv38OPLn0+/vv37+PPr38+/v///AAYo4IAEFmjggQgmqOCCDDbo4IMQRijhhBRWaOGFGGao4YYcdujhhyCGKOKIJJZo4okopqjiiiy26OKLMMYo44w01mjjjTjmqOOOPPbo449ABinkkEQWaeSRSCap5JJMNunkk1BGKeWUVFZp5ZVYZqnlllx26eWXYIYp5phklmnmmWimqeaabLbp5ptwxinnnHTWaeedeOap55589unnn4AGKuighBZq6KGIJqrooow26uijkEYq6aSUVmrppZhmqummnHbq6aeghirqqKSWauqpzO2j6qqr+snqq7Dm/wnrrLHWSeutrNKJ666qysnrr3D+KqybwhbLZrHIqonssmkum+yZzjJrJq+6aKGFANbe8myZxUIQ7bTdRrsPt+F+Syay3po7Jrrikitsus66+yu80q4r7rZi3otvmPoaK2+/tEILMK4CDxxwwQbnimbCtS7McK9rPkyswcEC7Ku+urZra7x4+svnraiGLPLIJJds8skop6zyyiy37PLLMMfcUgE011yznzbnrHOeOve8c50+B20znUIXTbOcRicNZ9JMu8n002w+LfVDZmgp9dVpXj31mVpjbWbXW5cJNtRij032mGafLWbaTZPJttJuv1102XIHTXfdPd+Nd8567/99c997c+330F8P/nfhg2dtuJqJrxl4m3UvzTbSZhMNtp1d89w2n3bL7PnnoIcu+uikl2766ainrvrqrLfu+uuwxy777LRTJkjtQiZyKCGBJIoB7kP+TighwBdv/PHIJ6/88sw37/zz0Ecv/fTUV2/99dhnr/323Hfv/ffghy/++OSXb/756Kev/vrst+/++/DHL//89Ndv//3456///vz37///AAygAAdIwAIa8IAITKACF8jABjrwgRAkEAUMEo8fUWAHtpDHBDGCiYxskCEV/OBAKsgQEQqEhBShgApVKBB7SCMa15gEQlbIQn64UBrS8MR9KFCNTcTDhDMBIkL/QkjBhgARhRPZ4Ar5QUIaPAMPBznieNSgEQoMgYlCZAkF4qGKaXjjDlZEBjWQccWDcHEa4LiDQFT4wxXG4xXVoMYUtmCNcHSCAj4IhjSYAYQtUgAI39gCHe1IgSAUoxq7gAcFeMALZ1DjC/xYBj9YiMIuWMMgYZCifiiZxZVQwB53pII5+NELSVBAErxAyD3uiIVRTtKPK7yHHvgRCWHIIgw9UAcFcMEHClBikvGAATTSQIFb5pICu4AEBeyADwrQAgz8kEI3+GGDVzJxIC5gRw0FoopdXKEgSNzhBH8YRHzsQCDy4Ec6YkCBGKQDIeacYDpf2UYV2gMG/IgBO2xw/4lW0IMC6MDnCm6wxVlUQoX89CcFzsHOFtSDH+fAoTTGsYI1jnOFMziHClMhDTXyowixgEUNbygNLIgTiziZxzbVwU53ImQek7wmPWlIj4rGoBzKuMQRVLqOGFj0HtiYhQpzulMKtIOdMLAHP9YhA36s4AwDoeRA0ICMJWIzE78gSDjtw0mZsJGTvVAmJHoxxJiS8KsrxEcdaGkLeNzACvmgADHyQAFLrGKLK2jGJSjgVrhSQBh01cM9KAAMPvCDDsngRw2WSEIeYAMN2+THHoYxB3Dux42dVAkssViEZFAjGUQo6zgtWs8t2oIaxfgBKsThi6NWQRrTKMYO/PgDckV8YbWtjcEUqEGNVigyCsmYxjOoQAFmjPSF1gCjCS9RUcv2SISjHWFFWFhDW3CBH16gxpegK9MTTpeGAukCNZYRjS0QKCAAIfkEAS0A+gAsDAATAHMBxwGH/f7///z2/Pz8//v7+Pv/+Pr89vz98Pv86vrw/Pn/+vX//vnx/vbp8/j+6Pnu/vTk8fHy/enI/enH5+/+4ujw/efD/OfC/OW9/ODg/Nra/NfX+9XV6tX9+9DQ+sbG+sPD+cFi+LZI97ZH+LGx+Kur9qMZ9aEU9aAQ9Z4L2PXi4Obu2eb93+Xt3uTs1OT93ePr3OLr2+Hq2+Hp2d/n2N7n193m1tzkz+H9z+D9zd/91dvk1Nrj09ni0djg0dfg0Nbfz9Xey9XhztTdzdTdzNPczNLby9Ha06j7we30yfHYyPDXxvDVxPDUwu/Tv+7QtOvJyt39ytDZyc/Zx83WxszWxcvVxMrUw8rTw8nSwcfRxMbKvsXPvsTOvMLMuL7Itr3HtbzGtLvFsLbBq+nCjeGsdduaddfnr7XArrS/q7K9qa+6qK+6p665Z9iRXtWKU9KBM8prKsdkKMdiJcZgpau3pKu2oqm0oKayn6axnKKum6KtmqGsmaCsmJ+rdqj5bqP4IsVeBrbU9pOT9YuL9IGBu3v583h483Fx8mJi8FVVqFX38EtL70hI70ZG70REl52plp2plZyok5qmkpilkZikkJejj5aijpWiipGeiY+ch46bhIuYhIuXg4qXgYiVf4aTYZr4Xpj4Ron3O4L2d36Mdn2LdXyKdHuJcnmHcXmGcXiGcHeFb3aEZWx7Yml4YWh3YGd2XmZ1XmV0X2RuXWRzXGNyW2JxWmJxXWFsWWFwWWBvV15uVFtqU1pqUllpUVloUFhnUFdnT1ZmTVRkTFRjS1NjS1JiSlFhSVBgSFBgR09fRk5eRk1dRUxcREtcQ0tbQkpaQUlZQUhZQEdYP0dXPUVVOUFSM0FVOEBRNz5PNj5ONT1ONDxNMztMMzpLMjlLMDhJLTVGKzNEKDBBJy9BJi5AJS0/JSw+JCs9Iys9Iio8ISk7ICg6ICc6Hyc5GyM2GyI1GiI0GCAzFx8yFh4xFh4wFR0vFBwvERksERgnAAAAAAAAAAAAAAAAAAAAAAAACP8A9QkcSLCgwYMIEypcyLChw4cDywh0ArGixYsYM67IyLGjx48gQ4ocOdLNQJMkU6pcybKly5cwY2JsIrMmy1E2c+rcybOnz59AgwodSrSo0aNIkyoV+Wap06dQoxJtE1HqTlFWs2rdyrWr169gw4odS7as2bNo06pdy7at27dw48qdS7eu3bt48+rdy7ev37+AAwseTLiw4cOIEytezLix48eQI0ueTLmy5cuYM2vezLmz58+gQ4seTbq06dOoU6tezbq169ewY8ueTbu27du4c+vezbu379/AgwsfTry48ePIkytfzry58+fQo0ufTr269evYs2vfzr279+/gw4v/H0++vPnz6NOrX8++vfv38OPLn0+/vv37+PPr38+/v///AAYo4IAEFmjggQgmqOCCDDbo4IMQRijhhBRWaOGFGGao4YYcdujhhyCGKOKIJJZo4okopqjiiiy26OKLMMYo44w01mjjjTjmqOOOPPbo449ABinkkEQWaeSRSCap5JJMNunkk1BGKeWUVFZp5ZVYZqnlllx26eWXYIYp5phklmnmmWimqeaabLKVz5twwtnmQ3HWaeecCdmp5514ErTnn3H2KRCghL7ZZ6GIzonoomwu6qiajkaKZqSUnkmppGVeWimZheKihRYCfDoLpmM6CoGmnJqqaT6lqoqqmJGe//pqmLGu2uqisl56K6K5bkrrqqSCCWywXw776K7G7plpsoAuy6yyzj4bqJnS8klttYamiW2jzyqa7KHDCqoPsOIOqmu5Ax2LrkF/ruvuu/DGK++89NZr77345qvvvvz26++/ACtXwMAEE0xvwQgn/G7CDCtcbsMQFyxuxBQP3GfFGM+J8cZsbuyxmh6HjGbIJJ9JsshlnlwymSqjPGbLH78Mc8xhzkwzmDZzLGbOGe/MM8Uy/wxx0EIzTHTRCB+NtMFKI53y0hKzDDXTUkNt8tQjLw1y0R3/rHHOF888ccvoqrywzvIOHfDabLft9ttwxy333HTXbffdeOet99589//t99+ABy744IQXbvjhiCeu+OKMN+7445BHLvnklFdu+eWYZ6755px37vnnoIcu+uikl2766ainrvrqrLfu+uuwxy777LTXDtkgtu+IiL+C5O7778AHL/zwxBdv/PHIJ6/88sw37/zz0Ecv/fTUV2/99dhnr/323Hfv/ffghy/++OSXb/756Kev/vrst+/++/DHL//89Ndv//3456///vz37///AAygAAdIwAIa8IAITKACF8hA8VBCGtpYA0cwcRdJJMgH0FBBFsCBpkzoAxsS5EgW8qCPGbDDX5KARb+q4A0fYKYVrPgPDawRhsx48D+96AMF+DUJeTzjGcOgXhcG1saF/wQEACH5BAEtAPsALA4AEwBxAccBh/3+///89vz8/P/7+/j7//j6/Pb8/fD7/Or68Pz5//r1//758f726fP4/uj57v705PHx8v3pyP3px+fv/uLo8P3nw/znwvzlvfzg4Pza2vzX1/vV1erV/fvQ0PrGxvrDw/nBYvi2SPe2R/ixsfirq/WiF/WgEPWeC9jw6+Dm7tnm/d/l7d7k7NTk/d3j69zi69vh6tvh6c/h/drg6Nnf59je59fd5tbc5M/g/c3f/dXb5NTa49PZ4tLY4dHY4NHX4NDW38/V3svV4c7U3c3U3czT3MzS28vR2tOo+8Ht9Mnx2Mfw1sTw1MHv0rTrycrd/crQ2cnP2cjP2MfN1sbM1sXL1cTK1MPK08LI0sHH0cTGyr7Fz77EzrzCzLi+yLa9x7W8xrS7xbC3wbC2wavpwo3hrK+1wK20vquxvKmvuqivunXZtGfYkVnUhlLSgTvMcCrHZCjHYiXGYKast6SrtqKptKGos6Cmsp+msZyjr5uirZqhrJmgrJifq3Om+SLFXga21PaTk/WLi/SBgbt7+fN1dfJiYvBVVahV9/BKSu9GRu9ERJedqZadqZWcqJSappKYpZCXo4+Woo6VoouSnomPnISLmISLl4OKl4KJloGIlYCHlH+Gk2Ga+F6Y+EaJ9zuC9nqBjnd+jHZ9i3V8inR7iXJ5h3F4hnB3hW92hG10gmpxf2hwfmdufGVse2JpeGFod15mdV5ldF9kbl1kc1xjcl1hbFticVpicVlhcFlgb1hfbldeblRbalJZaVFZaFBYZ1BXZ09WZk1UZExUY0tTY0tSYkpRYUlQYEhQYEdPX0ZOXkZNXUVMXERLXENLW0JKWkFJWUFIWUBHWD9HVz5GVj1EVTNBVThAUTg/UDc+TzY+TjU9TjM7TDM6SzI5Sy42SC01RiszRCgwQScvQSYuQCUtPyUsPiQrPSMrPSIqPCEpOyAoOiAnOh8nOR4mOBsjNhsiNRoiNBggMxcfMhYeMRYeMBUdLxQcLxEZLBEYJwAAAAAAAAAAAAAAAAAAAAj/APcJHEiwoMGDCBMqXMiwocOH+9ag2NfkDcSLGDNq3Ohno8ePIEOKHElyYImSHtssEchmJcqXMGPKnEmzps2bF5u4wcmzp8+fQIMKHUrUpp+ORZMqDXpyqdOnUKNKnTpyJ9WrWLNqJdh0KZutYMOKHfsSxUqLZNOqXcu2rdu3cOPKnUu3rt27ePPq3cu3r9+/gAMLHky4sOHDiBMrXsy4sePHkCNLnky5suXLmDNr3sy5s+fPoEOLHk26tOnTqFOrXs26tevXsGPLnk27tu3buHPr3s27t+/fwIMLH068uPHjyJMrX868ufPn0KNLn069uvXr2LNr3869u/fv4MOL/x9Pvrz58+jTq1/Pvr379/Djy59Pv779+/jz69/Pv7///wAGKOCABBZo4IEIJqjgggw26OCDEEYo4YQUVmjhhRhmqOGGHHbo4YcghijiiCSWaOKJKKao4oostujiizDGKOOMNNZo44045qjjjjz26OOPQAYp5JBEFmnkkUgmqeSSTDbp5JNQRinllFRWaeWVWGap5ZZcdunll2CGKeaYZJZp5plopqnmmmy26eabcMYp55x01mnnnXg2pM+efPIpVAGABhrok30WaihPgiaqqJKGNnooTYpGuqiRjlba50ySZipokZZ2umdMmoYK6JCelvqSqKgGWeqqJaHq6o+rxv86kqu09hjrrSHRquuOt/b6ka7A6tgrrh4BuyuOw/qqkbHB3uipLVpoIUC0sxCbEbPH2hgrBMluhG2t2m6brD7Xfgsujbdy2y1G5p47Y7rjltuuqOGuqu6w8s6rab2l3qvsRfrSWyO86wIc8L4Dj2stRAcjjK7CsrLbsKT8QtxpvhNvWrHFjXqbscYbc1yoxx+P6qzIlZJcco4od1zsyiy3PPLLH/Mq86cg1czjzbM2DCvKrQasKsenzksqxKCay2m8Mn17ZMFNG8soqzi5u2TKQWWa59Zcd+3112CHLfbYZJdt9tlop6322my37fbbcMct99x012333XjnrffefPf/7fffgAcu+OCEF2744YgnrvjijDfu+OOQRy755JRXbvnlmGeu+eacd+7556CHLvropJdu+umop676Gqq37vrrsMcu++y012777bjnrvvuvPfu++/ABy/88MQXb/zxyCev/PLMN+/889BHL/301Fdv/fXYZ6/99hslcrcicxcit/huk7+P99ynr/767Lfv/vvwxy///PTXb//9+Oev//789+///wAMoAAHSMACGvCACEygAhfIwAY68IEQjKAEJ0jBClrwghjMoAY3yMEOevCDIAyhCEdIwhKa8IQoTKEKV8jCFrrwhTCMYWPgQRAKIGkGvHgGNujgEUrIxIacsKFA/2g4ECE2hIgCMSJG6vEMZ1ADEhSIYhQVwsRnPOMSUpxif06xj01kggJEGEdUbAgPIyJxH0pcyBnTCBEi0oAZeUiiFg+yxvVkAyQ7cME+0BAOnIBDChRAxioocIZd7AAXy4gGGChQCW1kQw2iyEcypHjGfaRCGtGYwham4Q1LUMAHvnhGMoBAgTICgRtb2GQnKRAEYUjjFu6gwCETuUhkSHEfSPTCNIpowzHUcIi/LNAt6IEGnKzCESlQBjQoEIpHwCIMFIjCNijADhtkoRa4nGIpCWKPPeyjEb9wxRh4gA4K0KIPFICEK0rpgmYUU5zk3MctGEGBO9yDAs+M5jRtgP9GMg6EBerg5T5KcYsryHGbRTQQBeyAzZvM4RVdQAUybLCMIJTDis8IRwpk8Ys0kFGLZ6yHHl+gDhtM4hTzoIA5XECBFNyglK+IhA1NitJ9lOMFFFgBPShwUStqNIsI3UcMyiEQUjwDDwIpQitUIccqPgMLQAUQK1bQ0nfgJAbboIQdRFEHaVAgHTBoqRlsaAZfxCKbCJlHCvbxgnEcYxJHkMdXcWpDCtjDGq8QyFvjuo914NQF9fhqWFMw1rr6UyBnKIZA98GCSvBCjnUcUC3yQIExVIMnx0hGD9LgDFJQoBfopIMxbgANFtBgHRSQx1oPco86fFMW7riBFfBBgWCt6IECkjBFKZM5iX3Edrb7+MVt92CPz4bWGBSoQT9xKZAdWOMMB90HH4Axh4NGVkBRcAY0lJEFnljiG/uwQT7EQAEoGAMazKACBTSBDW1UggLEGEZCZBENYfxgFN/QhV+r8AxoCEMHpaTAD8QBBvzq9wVTiEY0ThFL86JXvZOcIhOdMQ08RHUfk1jtcq9rpEoGEyOy6MI+vhANbbKRTB5OaEa8EA1kOIMLF1ZQQAAAIfkEAS0A/QAsDgATAF4BxwGH/f7///z2/Pz8//v7+Pv/+Pr89vz98Pv86vrw/Pn/+vX//vnx/vbp8/j+6Pnu/vTk8fHy/e3t/erK/enI/enH5+/+4ujw/efD/OfC/OW9/ODg/Nra/NfX+9XV6tX9+9DQ+sbG+sPD+cFi+LZI97ZH+LGx+Kur9qMZ9aEU9aAQ9Z4L2PXi2uf94Obu2eb93+Xt3uTs1OT93ePr3OLr2+Hq2+Hp2d/n2N7n193m1tzkz+H9z+D9zd/91dvk1Nrj09ni0djg0dfg0Nbfz9Xey9XhztTdzdTdzNPczNLby9Ha1q/7z6H7we30yfHYyPDXxvDVxPDUwe/StOvJyt39ytDZyc/Zx83WxszWxcvVxMrUw8rTw8nSwcfRxMbKvsXPvcPNuL7Itr3HtbzGtLvFsLfBsLbBq+nCjeGsetyer7XArrS/q7K9qa+6p665pau3pKu2cti/bdmVYNaLU9KBO8xwM8prKMdiJcZgoqm0oKayn6axnKKum6KtmqGsmaCsmJ+rmJ6qdqj5bqP4IsVeBrbU9pOT9YuL9IKC9H9/u3v583h483Fx8mJi8FVVqFX38EtL70hI70ZG70REl52plp2plZyok5mlkpilkJejj5aijpWiipGeiY+ch46bhIuYhIuXg4qXgYiVf4aTYZr4Xpj4Ron3O4L2d36Mdn2LdXyKdHuJcnmHcXmGcXiGcHeFb3aEbXSCZ258ZWx7Yml4YWh3XmZ1XmV0X2RuXWRzXGNyW2JxWmJxXWFsWWFwWWBvV15uVFtqUllpUVloUFhnUFdnT1ZmTVRkTFRjS1NjS1JiSlFhSVBgSFBgR09fRk5eRk1dRUxcREtcQ0tbQkpaQUlZQUhZQEdYP0dXPkZWPUVVPURVM0FVOEBRNz5PNj5ONT1ONDxNMztMMzpLMjlLLTVGKzNEKDBBJy9BJi5AJS0/JSw+JCs9Iys9Iio8ISk7ICg6ICc6Hyc5GyM2GyI1GiI0GCAzFx8yFh4xFh4wFR0vFBwvERksERgnAAAAAAAAAAAACP8A+wkcSLCgwYMIEypcyLChw4f90KyASLGixYsYBbIIlLGjx48gQ4osiGJkRjlO7PST88Sky5cwY8qcSbOmzTk2c+rcybOnz59Ag44UxFGo0aMmSyJdyrSp06dQH+KMSrWq1aUnJBiNM5Dr1a9gw4rFuMJJvzpj06pdy7at27dw48qdS7eu3bt48+rdy7ev37+AAwseTLiw4cOIEytezLix48eQI0ueTLmy5cuYM2vezLmz58+gQ4seTbq06dOoU6tezbq169ewY8ueTbu27du4c+vezbu379/AgwsfTry48ePIkytfzry58+fQo0ufTr269evYs2vfzr279+/gw4v/H0++vPnz6NOrX8++vfv38OPLn0+/vv37+PPr38+/v///AAYo4IAEFmjggQgmqOCCDDbo4IMQRijhhBRWaOGFGGao4YYcdujhhyCGKOKIJJZo4okopqjiiiy26OKLLPIj44wzwqgWjTjmaONXOfao445R+SgkjUA+NeSRMhbJFJJMKnkUk1A6GRSUVErpE5VYWrkTllxqmROXWXpJE5hdiikTkrx00YUAat4SppkwUQkBmXDGKSeZ/NTpEpZz0qnnSHzi+Segd/o5KEiBGnqoR4mCuSiieL75aEaRSjrpRZVWeWlHmSK5KaOdDvkpp6EKOSqppeJ4Kqqp1rgqpa0m//kqq6HO+lGqtkKaaa4h7cprr4L+KpKiwgLbZLExmYrsssw26+yz0EYr7bTUVmvttdhmq+223Hbr7bdrFSDuuOOCyxC56KZrrkHptqvuuv24Ky+5685rr7jg3quvt/r2y22/AGsL8MDYDmzwtQYTXG3CB1PLsMLTPhxwxBJPHG3FFkOLsb/Sbrxvxx7bS3HI8o5Mcrsmn4xuyiqXy7LKC7dMr8Myu0yzzAjXXHDLAp/8b8j8bpxvxfU+DG+8CR89UMZKL+1u01BHLfXUVFdt9dVYZ6311lx37fXXYIct9thkl2322WinrfbabLft9ttwxy333HTXbffdeOet99589//t99+ABy744IQXbvjhiCeu+OKMN+7445BHLvnklFdu+eWYZ6755px3/hscnocu+uikl2766ainrvrqrLfu+uuwxy777LTXbvvtuOeu++689+7778AHL/zwxBdv/PHIJ6/88swfvwTpj4CNyECQfB2BIl9jv/UiA0XP9SF6KtH8+OSXb/756Kev/vrst+/++/DHL//89Ndv//3456///vz37///AAygAAdIwAIa8IAITKACF8jABjrwgRCMoAQnSMEKWvCCGMygBjfIwQ568IMgDKEIR0jCEprwhChskAUIIg8pWeCFbsBHRjYRE1H0wwItFMgKB5LDhuxQID2syAv/h3gPaUTjGpZQyBBfWERpSOMT7WHFDS2AA2zQ4yktxOFAftiPIC6Ei16EyA5fmEMbPGMPCQGjdrjBho68MBZ8CGNMcKiKaXxDDxYoAjKogYwi4LAWnTjFPphBx2mEQw8FWaI8XlENaljBC9YQhycsAIRgSIMZQsChBYQADi9AUpIWGEIxqqGLeFjAB7twBjXE0I9lbLGHYLDGDQlSBh2ykD5kEIYWbWKBe0zyCuewQC8qYYFK7MIC+GgDGW+ID0/0YwvnYOEKX4iPPliAEsKQRRl+sA4L4OIPFriELLooA2isoR/a5KYFdDEJC+QhHxagxRj6UQVv9AMHrxwIDNox/8UdqkIXWlCjfGagjSPssiYWyEcPXjgPC6hjBhaYgTosUI8WLDOhPRDIPKQ5xXvIIKLtwIEmWlEPC6Tjoy3IQRdngYkVipSkFkAHRF9gj5g6URrksGg+b1gDdAgkFdJAZD+OEAtYLLGJ0tjCewAxDifuIxe8pMcQ5WGBdUBUolq86BUPQtUpVjSi5lCGJpJwRXZAdIf4yMYsVihWslrAHRCVwT0swA4a9KMFaZilDnuoBmTo8IUCgQEnfnFL+QD2oDWhKhmF2c5J9EKTL6SHReXYxWkmFA/XtEU8cpAFfViAGHywQCZW0cUWNEMT/dhsZy0gjND2AR8WAMYf+vGGZIX04wZ/zaEPtKGGfgrED8Nwg0Djo0iddFWTR0gGNZJhBMha4BjGQGwip2oLahQjCKgYhy/gigVpTKMYC6VqEMohhuxudwZWoAY1WmFKKiRjGs+4Qj8ISUQjWkOogBWIJlqgVyBaiYsFoSxDDmsBW3yhH2GgxrMAXFghLhEM1FhGNLywn4AAACH5BAEtAPsALAwAEwBgAccBh/3+///89vz8/P/7+/j7//j6/Pb8/fD7/Or68Pz5//r1//758f726fP4/uj57v705PHx8v3pyP3px+fv/uLo8P3nw/znwvzlvfzg4Pza2vzX1/vV1erV/fvQ0PrGxvrDw/nBYve2R/ixsfirq/WiF/WgEPWeC9j14trn/eDm7tnm/d/l7d7k7NTk/d3j69zi69vh6tvh6c/h/dnf59je59fd5tbc5M/g/c3f/dXb5NTa49PZ4tLY4dHY4NHX4NDW38/V3svV4c7U3c3U3czT3MzS28vR2tOo+8Ht9Mnx2Mjw18bw1cTw1MHv0srQ2cnP2cjP2MjO18fN1sbM1sXL1cTK1MPK08LI0sHH0cTGyr7Fz77EzrzCzLi+yLa9x7W8xrS7xbG4wrC2waHmuq+1wK60v620vquyvamvuqivunXZtGfYkVnUhlLSgTvMcCrHZCjHYiXGYKast6SrtqKptKGos6Gns6Cmsp+msZ2kr5uirZqhrJmgrJifq3ao+W6j+CLFXga21PWQkPSBgbt7+fN4ePNxcfJiYvBVVahV9/BLS+9ISO9GRu9ERJedqZadqZWcqJSappKYpY+Woo6VooyTn4uSnomQnYmPnIiPm4WMmYSLmISLl4OKl4GIlYCHlH+Gk2Ga+F6Y+EaJ9zuC9nqBjnd+jHZ9i3V8inR7iXJ5h3F4hnB3hW92hG10gmxzgWlwfmVse2NqeGJpeGFod15mdV5ldF5kcVxjclticVpicV1hbFlhcFlgb1hfbldeblRbalJZaVFZaFBYZ1BXZ09WZk1UZExUY0tTY0tSYkpRYUlQYEhQYEdPX0ZOXkZNXUVMXERLXENLW0JKWkFJWUFIWUBHWD9HVz1FVTNBVThAUTg/UDc+TzY+TjU9TjM7TDM6SzI5Sy42SC01RiszRCgwQSYuQCUtPyUsPiQrPSMrPSIqPCEpOyAoOiAnOh8nORsjNhsiNRoiNBggMxcfMhYeMRYeMBUdLxQcLxEZLBEYJwAAAAAAAAAAAAAAAAAAAAj/APcJHEiwoMGDCBMqXMiwocOHA9VAnEixosWLGDNq3Mixo0eGJD5iZLPvzb41IlOqXMmypcuXMGMObDNwjMybOHPq3Mmzp8+fQIMK/RlyqNGjBHEgXcq0aUGaAm06nUq1ak8SEUL8RClwTROrYMOKHTtRahM3ZNOqXcu2rdu3cOPKnUu3rt27ePPq3cu3r9+/gAMLHky4sOHDiBMrXsy4sePHkCNLnky5suXLmDNr3sy5s+fPoEOLHk26tOnTqFOrXs26tevXsGPLnk27tu3buHPr3s27t+/fwIMLH068uPHjyJMrX868ufPn0KNLn069uvXr2LNr3869u/fv4MOL/x9Pvrz58+jTq1/Pvr379/Djy59Pv779+/jz69/Pv7///wAGKOCABBZo4IEIJqjgggw26OCDEEYo4YQUVmjhhRhmqOGGHHbo4YcghijiiCSWaOKJKKao4oostujii+vpI+OMM/ZUwI044gjjQzT26ONNOQYp5I4J+Wjkjy4JqeSQRBJ05JM0trTklDk2KRCUWMq4EpVc3thklmCm1OWYO4Jp5kdjpvmimWx2lOabLbIp50Zv1rminHhmVOeeKuI5J0Z72omin3laFCifJ2a5SxZZCMDoLX9WdKigJrIJAaEXTQpnpZYSqo+kmm5KopyXYkpRqKKOSKqnoKLaJadmlv/qZ6uuUgkrmLIWOlGtr5a4qqm78mqrr55GCpGww45abJunIrvkrctiSauzVUIbrZGZUluttdf2mK22Xiba7ZPfgpviuNgCau656HqrrrZ3tqulRvCyKK+byK45Lpq8lnmtmK5+ueyWoVq5T7FSTmrwlbMmGejCTp4pU6oQR5zuTlNWrPHGHHfs8ccghyzyyCSXbPLJKKes8sost+zyyzDHLPPMNNds880456zzzjz37PPPQAct9NBEF2300UgnrfTSTDft9NNQRy311FRXbfXVWGet9dZcd+3112CHLfbYZJdt9tlop6322my37fbbcMct99x012333XjnrffefPf/7fffgAcu+OCEF2744YgnrvjijDfu+OOQRy755JRXbvnlmGeu+eacd+7556CHLvropJdu+j5+nK766qy37vrrsMcu++y012777bjnrvvuvPfu++/ABy/88MQXb/zxyCev/PLMN+/889BHL/301AsuiMdHpHV99Q8Osv3YDHAvvmeDfJz9+Oinr/767Lfv/vvwxy///PTXb//9+Oev//789+///wAMoAAHSMACGvCACEygAhfIwAY68IEQjKAEJ0jBClrwghjMoAY3yMEOevCDIAyhCEdIwhKa8IQoTKEKV8jCE8GDIBSoGBrIIQ1poAIjlmBJDEERQ4G8cCA9bMgP/wUSRIrUQxrRuIYkKMBEJirkiDXkRBOd2J5V7AMSlWjiUmIIjyAOcR9FXMgXwwiRH87gGXogIhUPMsbsZGIf20hDRj5hBy3GRBxQoMAyYEEBM/hCB7pwBjW+QIFMcCOOpsgHM5r4xX20ohrUkIIWrAGOTVCgB8GQBjN+QIEu/sAbWphkJSkAhGJUIxfvoAAgBUnIZWhxiF2wBhBjKAYY+tCW83mFLKxRDCo0BBcWKUdBYAGJFDRjGhQoRSRoAQYKPKEbFGhHDbAAzC7GsJMEscce9vEIYcRCDDtIBwVw0QcKSCIWnXQBNM6wj2+Gcx+5cAQF7nAPCjDTmdCsARi5OP8QFqxjlvtIRS6soEZsApE+rrgEBfIADZnIYRZcYMUyauAMIJijhtIYRwpsIQw0cJGKX6yHC/bxgnXUgBKrmAcFzuECCqTABp2cxSRieNKU7sMcL6DACuhBgYvWUKNTNOg+YmAOgaBCGngQCBFi4Qo1QlEaVwgqfKKQApe6g4wriUE3KlEHU9ChGhRQBwxcSoYYkiEYtdhHFxEyjxSQtBzKoIQR5BHWnF7THtiYhUDiOtd9sCOnLqhHWMeagrJek58CKQMyALoPFlziF2ps43x+YYd9hKGhMlEGM3iAhmigggLAKOcckmGDabBgBuyggDzcepB70IGbtniHDaqADwquEEMPFJiEKjppTErsQ7a03YcwcLsHe4BWtMmgAA32qVaB6AAbZijoPvgwDDkUVLLysYI1pKEMX8pEE+HYRw3yIQYKOCEZ03jGFCjgCW1wAxMUOIYxEmILahTDB6cIRy/+SgVpTKMYOegkBXxAji/kd78vkAI1qLGKVJ43vetdpBOPGA1r4EGq+6AEa5mL3YU1EpcUsQUX9uEFajhxjTj78EEr0gVqLCMaW8AwfgICACH5BAEtAPsALAwAEwADAccBh/3+///89vz8/P/7+/j7//j6/Pb8/fD7/Or68Pz5//r1//758f726fP4/uj57v705PHx8v3pyP3px+fv/uLo8P3nw/znwvzlvfzg4Pza2vzX1/vV1erV/fvQ0PrGxvrDw/nBYvi2SPe2R/ivr/ajGfWhFPWgEPWeC9j14trn/eDm7tnm/d/l7d7k7NTk/d3j69zi69vh6tvh6dnf59je59fd5tbc5M/h/c/g/c3f/dXb5NTa49PZ4tHY4NHX4NDW38/V3svV4c7U3c3U3czT3MzS28vR2tOo+8Ht9Mnx2Mjw18bw1cTw1MHv0rTrycrd/crQ2cnP2cjO18fN1sbM1sXL1cTK1MPK08PJ0sTGysHH0b7Fz73Dzbi+yLa9x7W8xrS7xbC2wavpwo3hrHjaw6+1wK60v6yzvquyvamvuqeuuW7ZlmHWjFnUhjPKayjHYiXGYKWrt6SrtqKptKCmsp+msZ2ksJyirpuirZqhrJmgrJifq3ao+W6j+CLFXga21PaTk/WLi/SBgbt7+fN4ePNxcfJiYvBVVahV9/BLS+9ISO9GRu9ERJedqZadqZWcqJOZpZKYpZCXo4+Woo6VoouSnoqRnomPnIeOm4SLmISLl4OKl4GIlYCHlH+Gk2Ga+F6Y+EaJ9zuC9nd+jHZ9i3V8inR7iXJ5h3F5hnF4hnB3hW92hGtygWdufGVse2RremJpeGFod15mdV5ldF9kbl1kc1xjclticVpicV1hbFlhcFlgb1deblRbalJZaVFZaFBYZ1BXZ09WZk5VZU1UZExUY0tTY0tSYkpRYUlQYEhQYEdPX0ZOXkZNXUVMXERLXENLW0JKWkFJWUFIWUBHWD9HVz1FVT1EVTNBVThAUTc+TzY+TjU9TjQ8TTM7TDM6SzI5Sy41Ry01RiszRCgwQScvQSYuQCUtPyUsPiQrPSMrPSIqPCEpOyAoOiAnOh8nORsjNhsiNRoiNBggMxcfMhYeMRYeMBUdLxQcLxEZLBEYJwAAAAAAAAAAAAAAAAAAAAj/APcJHEiwoMGDCBMqXMiwocOHA9cMdAOxosWLGDNq3MgxY4mOINnse7NPJMiTKFOqXMmypcU2A8W4nEmzps2bOHPq3MmT5ceeQIOifCK0aE+YAmUaXco0KIl9IYpKFLjGSdOrWLPSHCPQCUWtYMOKHUu2rNmzaNOqXcu2rdu3cOPKnUu3rt27ePPq3cu3r9+/gAMLHky4sOHDiBMrXsy4sePHkCNLnky5suXLmDNr3sy5s+fPoEOLHk26tOnTqFOrXs26tevXsGPLnk27tu3buHPr3s27t+/fwE3rG06ceHDBxZMrP85XufPlzO8+n148el3q2Idbl5u9+/a33cN//2cbvvz4tOXTnzebvv16su3Vvw8b3/18rdlzZckiYD8t+fdhVR4E9QUo4ID16WNgU+kRWOCCSzWYIIQRIvgghUJJeCGGQGkYH4cZJgggiDyJOCKJOploHoo9qZgdix26SB2MLco4HY012pgcjjnqaByPJfqoHZA9ykhkUDoeGaKKShbFZJNOTgilURtOGaV3VmZ1Y5Zcdunll2CGKeaYZJZp5plopqnmmmy26eabcMYp55yFFWDnnXfSuRKefPapZ0d9BurnnxgJaiiehFp06KJ2JvoQo5A6yhCklEqaEKWYWmoQppxqOhCnoHq6D6idakpqqJaeWqqkqmbKaquuJv8Ka6yEzlqpo7ZGimuui77Kq6G+/hposMLySWyxeR5brKnIIppqs8k+26yo0BYg6qjIXivQstpuy2u3BOUKbkGzjrupquYedGq6l97K7kLAvivvvPTWa++9+Oar77789uvvvwAHLPDABBds8MEIJ6zwwgw37PDDEEcs8cQUV2zxxRhnrPHGHHfs8ccghyzyyCSXbPLJKKes8sost+zyyzDHLPPMNNds880456zzzjz37PPPQAct9NBEF2300UgnrfTSTDft9NNQRy311FRXbfXVWGet9dZcd+3112CHLfbYZJdt9tlop632vGSs7fbbcMct99x012333XjnrffefPf/7fffgAcu+OCEF2744YgnrvjijDfu+OOQRy55yYEkPELlk3cGyMEjMNz5wJ8XHHrmpJdu+umop6766qy37vrrsMcu++y012777bjnrvvuvPfu++/ABy/88MQXb/zxyCev/PLMN+/889BHL/301Fdv/fXYZ6/99tx37/33Y1JAEDxEqsCKNdJQoZUn+1BAvkDiD/R+Q/ELNL9FFOSffz3QPFMNJArR3/6gQUBNUAYV+7CEKfZRB19ohXzuG0j99nG/hUywghCJX/7eN4Nm3CEhF/zLJfaRjTRspBpW2McLOoET95kiGtyoAwWEYAxpGEMI7pMFJkaRD2W4MBreqENB/wQIj1VMQxpT2AI1vpEJCvTAF9BQxg/cR4EfdGMLSmQiBYAgjGnc4h0U2AEumCGNL+wjGRKcXxeo0T6ChAF+49OMOzQBjV9IoSG1wEg5hliPJlKhHBTQxSMo8AhcUMAeathg++yRiX1gYY/yE1/+7JEHCjjiF64IAw/SQYFa7IECkXAFBV/gDDTsI5ObpMAtGkEBOtyDArEAwz6isI191CCNA2nBOtqXP4GY4hZXCGFm4mGHfdihGS28hw7yFw8KoAMGFIABOigwDxUokgLKFEg8xidJCtTjBdFcRw0okYp5UOAc4FSBDSgIC0mIb5zlpIA5oMkCesiTgNAQhzVx2f8+GZhDIKWAhhD3QYRWsEKA/CMgFiwTDp5QQB76gwcF0gFNaUbwmvJAiER5Wc1okgMZlDBCRtUBzfjZwxqwEB9IRUoBdkDzBfWggDpisA8VlKGN8JufGYwBv17uowWX4EUcM/OKM+zjDMzIiUQ3GEhWNkIXVMyfPKyJQft18x5zsOQs3mEDK+CDAsHAAwUmcQoKqmAZlNgHV71KgV+INQ/2oEAv9rAPORxjHzTo6ft2cA0z8DJ+egBGHISJmR8M4xnL0MlGqUiEY0jjGEOIKgWKQYwIIoSIs5CGMHxACnDswqVVgEY0hLFMifpgHF/o7GdhMAVpSCMVYITCMaLRDPUx+VB//HsGNQbq031QQgU4td+RJliQqtKvm7Pgwj68II0/EXeo+BNgF6SRjGdsATQBAQAh+QQBLQD9ACwOAAoAXgHQAYf//Pb/+/v8/Pz4+vz2/P3w+/zq+vD8+f/++fH+9un69f/o+e7+9OTx8fL97e396sr96cj96cfi6PD958P858L85b384uL83d382tr819f71dXq1f370tL7zs76xsb6w8P5wWL5ubn4vVn4tkj3tkf4sbH4q6v2pBv1ohb1oRT1oBD1ngvY9eLh5+/g5u7f5e3e5Ozd4+vc4uvb4erb4enZ3+fY3ufX3ebW3OTV2+TU2uPT2eLR2ODR1+DQ1t/P1d7L1eHO1N3N1N3M09zM0tvL0drWr/vPofvB7fTJ8djI8NfH8NbG8NXE8NTC79O/7tC068m068jK0NnJz9nHzdbGzNbFy9XEytTDytPDydLCyNLBx9HExsq+xc++xM68wsy4vsi2vce1vMa0u8WwtsGu6sSn6L+N4ax63J5y2L+vtcCutL+rsr2pr7pt2ZVh1oxe1YpT0oEzymsqx2Qox2ImxmEjxV+nrrmlq7ekq7aiqbShqLOgprKfprGcoq6boq2aoayZoKyYn6sixV4GttT2mZn1jY31i4v0goL0f3+7e/nzeHjzcXHyYmLwVVWoVffwS0vvSEjvRkbvRESXnamWnamVnKiTmaWSmKWQl6OPlqKOlaKLkp6JkJ2Jj5yHjpuEi5iEi5eDipeBiJV/hpM7gvZ3fox2fYt1fIp0e4lyeYdxeYZxeIZwd4VvdoRlbHtjanhiaXhhaHdeZnVeZXRfZG5dZHNcY3JbYnFaYnFdYWxZYXBZYG9XXm5UW2pTWmpSWWlRWWhQWGdQV2dPVmZNVGRMVGNLU2NLUmJKUWFJUGBIUGBHT19GTl5GTV1FTFxES1xDS1tCSlpBSVlBSFlAR1g/R1c+RlY9RVU9RFUzQVU4QFE4P1A3Pk82Pk41PU40PE0zO0wzOksyOUstNUYrM0QoMEEnL0EmLkAlLT8lLD4kKz0jKz0iKjwhKTsgKDogJzofJzkbIzYbIjUaIjQYIDMXHzIWHjEWHjAVHS8UHC8RGSwRGCcAAAAAAAAAAAAI/wD7CRxIsKDBgwgTKlzIsKHDhxAjSpxIseJAfhgzZrTIsaPHjyBDihxJsqRJhBpTqjzJsqXLlzBjyjSpsubKmThz6tzJs6dDm0A1+hxKtKjRoxODKsWItKnTp1BlLp0atarVq1h/TqWatavXr0i3igVLtqzZl2LTnl1LFo3AJ2wtpp0bt65CFP1E+ISzZI7dinPV/h2M1EmcgWbqEG4YmO7ix5CzLtXFhYuAyrUER97MOezWBo07i355uJ+dMqMJpgUdOjXYEw+GuhnoJoprgasb87sNVi9vz591/x5O3GPu1sWTK9caHPny59BVi2UdOLr16LodX99ePLtm7uBve/8fG7686/FLzasfjV7p+veb2weFT/+x/Jr18w++f1O/f7b8bfTfgGsFSOCBZ92H4IJltcfgg2CNB+GEXmVH4YWSVYfhhleRx+GHHdoE4ogklmjiiSimqOKKLLbo4oswxijjjDTWaOONOOao44489ujjj0AGKeSQRBZp5JFIJqnkkkzKOMCTUELZZI1RVmnllC9aqeWVWKq45ZdRdokimGQ+KWaJZaZ5Johptrnmhm3G+SaFcdY554N15nnngnnauSeBfer553+B+jmofoXKeWh+iRq66HuNKvoopJGqOSmllZJ5KaaZfrnpep1q+ql5oYI5Kqmlbnlqeamqump4rVb/+SqrsUo5K3i12nord7nuCmutvv6aarC0hkosqpkeq16yyi7baLOcCgotqH1OW5+k1jLqarbcduvtt+CGK+645JZr7rnopqvuuuy26+678MYr77z01mvvvfjmq+++/Pbr778AByzwwAQXbPDBCCes8MIMN+zwwxBHLPHEFFds8cUYZ6zxxhx37PHHIIcs8sgkl2zyySinrPLKLLfs8sswxyzzzDTXbPPNOOes88489+zzz0AHLfTQRBdt9NFIJ6300kw37fTTUEct9dRUV2311VhnrfXWXHft9ddghy322GSXbfbZaKet9tpst+3223DHLffcdNdt991456333nz3/+3334AHLvjghBdu+OGIJ6744ow37vjjkEcu+eSUV2755ZhnrvnmnHfu+eeghy766KSXbvrpqKeu+uqst+6612m8LvvstNdu++2456777rz37vvvwAcv/PDEF2/88cgnr/zyzDfv/PPQRy/99NRXb/312Gev/fYwG8LxEV6Z4HUHXidSiNchXNCPA2CXsLX7AlmgtQmIDMRBxkZwr//+/Pfv//8ADKAAB0jAAhrwgAhMoAIXyMAGOvCBEIygBCdIwQpa8IIYzKAGN8jBDnrwgyAMoQhHSMISmvCEKEyhClfIwha68IUwjKEMZ0jDGtrwhjjMoQ53yMMeRq8X0YjGNUjisTUJSKAfmjiF0LjRESO2oBs+KKIE9gCLI2rNiNLQghUf9ApXIEQLq5LAGIZhxAl1olkS+IUayqi1K2DDiFsk3hfE5oVpBQQAIfkEAS0A+wAsDAAKAGAB0AGH/f7//vz4//v7+Pv/+Pr89vz98Pv86vrw/Pn/+vX//vnx/vbp8/j+6Pnu/vTk8fHy/enI/enH5+/+4ujw/efD/OfC/OW9/N7e/NfX+9XV6tX9+9DQ+sbG+sPD+cFi+LZI97ZH+K+v9qMZ9aEU9aAQ9Z4L2PDr4Obu2eb93+Xt3uTs1OT93ePr3OLr2+Hq2+Hpz+H92d/n2N7n193m1tzkz+D9zd/91dvk1Nrj09ni0djg0dfg0Nbfz9Xey9XhztTdzdTdzNPczNLby9Ha06j7we30yfHYx/DWxPDUwe/StOvJyt39ytDZyc/ZyM/Yx83WxszWxcvVxMrUw8rTwsjSwcfRxMbKvsXPvsTOvMLMu8HMuL7Itr3HtbzGtLvFs7nEsLfBsLbBoea6r7XArrS/rbS+q7K9qa+6qK+6ddm0Z9iRVtOEO8xwKsdkKMdiJcZgpqy3pKu2o6q1oqm0oaizoKayn6axnaSwnKKum6KtmqGsmaCsmJ+rc6b5IsVeBrbU9pOT9YuL9IGBu3v583h483Fx8mJi8FVVqFX38EpK70ZG70REl52plp2plZyolJqmkpilj5aijpWijJOfiZCdiY+ciI+bhYyZhIuYhIuXg4qXgYiVf4aTYZr4Xpj4Ron3O4L2eoGOd36Mdn2LdXyKdHuJcnmHcXiGcHeFb3aEa3KAZ258ZWx7Yml4YWh3X2d1XmZ1XmV0X2RuXWRzXGNyW2JxWmJxXWFsWWFwWWBvWF9uVFtqUllpUVloUFhnUFdnT1ZmTVRkTFRjS1NjS1JiSlFhSVBgSFBgR09fRk5eRk1dRUxcREtcQ0tbQkpaQUlZQUhZQEdYP0dXPkZWPUVVM0FVOEBROD9QNz5PNj5ONT1OMztMMzpLMjlLMTlKLjZILTVGKzNEKTBCKDBBJy9BJi5AJS0/JSw+JCs9Iys9Iio8ISk7ICg6ICc6Hyc5HSU3GyM2GyI1GiI0GCAzFx8yFh4xFh4wFR0vFBwvERksERgnAAAAAAAAAAAAAAAAAAAACP8A9wkcSLCgwYMIEypcyLChw4cQI0pMqK+iRYsTMyIExbFjR40gQ4ocSbKkyZMoT15cyTKlQo8wY7qcSbOmzZs4abLc2dJmzJ8ycwodSrSoUZI8k16sCbSpx6NQo0qdmlOp1YoznWrlSLWr169gGV4dm3Kr2bBo06o1OrbtSbNw18qdSxdpW7ck4eqty7evX4R3A4/US/ivYZMBwqYxsS8JG6GBI4fUOqAGDBR9CIM6zJnkiH0epq4ZqOYI5Mh3JztlwNGTBM2dY8tuPFqgmDc4UUvOuJU1x9ewZwsfXvPqLStWBCCXJZi3Vt99MgcnTr36yLsPdGvcWnkFgCWaN1v/Hx+2th8lubHr1jfRrG9PvqeTpy4CAlU1pNHfDJxdu0T3HH2CQnjizSdcYgKFRpUYJpj22H7q+ReRWZXZYEMnBBqo4YYE8bdeewTKx+GI1nkoIUQhikjiisKZiBqIKcbF4owtrtfchDHKSOOOnNl4I4o5nsXjkH/5mNp/QW5F5JJ9GXnVdkk2xeSUdDlpFZRR/kTllmpZqRSWWcLE5ZhhebmTamF+ROaaXZnZE5hpsinnVG5iJFKaXM2pJ1R1lhTnnoCy5eVbUQZqaFFWlhXkoYwOZWRWMTYqaVUf0pTipJhCuBtT4WXqqU1H5rTXp6SCylNUUpaq6qqsturqq7DG/yrrrLTWauutuOaq66689urrr8AGK+ywxBZr7LHIJqvsssw26+yz0EYr7bTUVmvttdhmq+223Hbr7bfghivuuOSWa+656Kar7rrstuvuu/DGK++89NZr77345qvvvvz26++/AAcs8MAEF2zwwQgnrPDCDDfs8MMQRyzxxBRXbPHFGGes8cYcd+zxxyCHLPLIJJds8skop6zyyiy37PLLMMcs88w012zzzTjnrPPOPPfs889ABy300EQXbfTRSCet9NJMN+3001BHLfXUVFdt9dVYZ6311lx37fXXYIct9thkl2322WinrfbabLft9ttwxy333HTXbffdeOet99589//t99+ABy744IQXbvjhiCeu+OKMN+7445BHLvnklFdu+eWYZ6755px37vnnoIcu+uikl2766ainrvrqrLfu+uuwxy777LTXbvvtuOeu++689+7778AHL/zwxBdv/PHIJ6/88sw37/zz0Ecv/fTUV2/99dhnr/323Hfv/ffghy++92mMb/756Kev/vrst+/++/DHL//89Ndv//3456///vz37///AAygAAdIwAIa8IAITKACF8jABjrwf4EwGhEOE4LEJWIDihMEIPaBAUUcLgQX2McCGFdBw5UwESEsXAgEMRAMCm2CD4yhDGdIwxra8IY4zKEOd8jDHvrwh0AMohD/h0jEIhrxiEhMohKXyMQmOvGJUIyiFKdIxSpa8YpYzKIWt8jFLnrxi2AMoxjHSMYymvGMaEyjGtfIxja68Y1wjKMc5xg2eBBkAkEzwzSYAY0vgGQSNMEjJ/AoEDsOhJANMaRAECmRejSDGdKAxAQmOUmFOLIZzcgEJStpr1PsQxxP2EcUvJEWPMIDkYrcByMXkspVQsSQMVAGHhbJyYO0UlyWEAgaQmINLkygC+MQyjecMAFjqGICZdAFDmyRjGd0YQKWwMY10CCKfByDkqncRyqg8YwnXCEa3MDEBHTAi2YcgwcTOCUPtHGFb4ZzAj0ABjRq4Y4JLLOZzzQGJfeh/8gtROOQeAzDHQs5UH5x4R7buIcchKIKR5wAGc6YQCge4QovTKAJ2ZgAO2ZQBVrws5LpJIg99LCPRvSCFWHIATomMAs+TAASrEgnC5Zhhn2gVKX7qAUjJlCHe0ygohfN6AxUacqBqEAdAN1HKWoxBVqG9JD9csYdJoCHVwgFDq3IAiqMMYNk9KAcmGwGOE4Qi16cwZScTGU9WLCPFqhjBpI4xTwmYA4WTOAENEhnKyKBR7jKdR/laMEEUkCPCYAVk2Pd5FP38YJyCIQUzbCDQIKwClXQ8pLNoIJi8/WOE9zVHUJ5QTYmQQdRzAEaE0iHC+46BjyOgRew+ChC5nGCtv+OoxiSGII8UitYPE7AHtRohUBwq9t9rEOwLKhHald7gtb6tqgCIcMwkroPFVBCF7S8Jb+oEYYJgMEaQynGMXRwBmaQYgK7cGkciEEDZ6ggBuuYgDxqe5B7zKGksXAHDaSAjwn8Ig8TiIQp0vlQSexDv/zdRy8ArAd7oFe9xJiADIjKT4HggBplcOo+9uALODhVu/vSgjOc0QwtDOUS3djHDPIBhgkwgRjOUAYUJrAJa2CjEhMQRjASEotnAGMHo+hGLo4bhWY4Axg3SOcEdhCOLgR5yC14wjOecYp6vjjGM75mJR3JjGjYYbP7kAR9KQzin2WzoBKJRRb2wYVngNQSlV07M1QnsoVnGIMZWABzwAICACH5BAEtAPsALBsACgBRAc4Bh/3+///89vz8/P/7+/j7//j6/Pb8/fD7/Pz5//r1//758f726fP4/v705PHx8v3pyP3px+fv/uLo8P3nw/znwvzlvfzi4vzd3fza2vzX1/vV1erV/fvS0vvOzvrGxvrDw/nBYvi2SPe2R/ixsfirq/akG/WiFvWhFPWgEPWeC/aZmfWNjfWLi/SCguDm7t/l7d7k7N3j69zi69vh6tvh6drn/dnm/dTk/c/h/dnf59je59fd5tbc5M/g/c3f/dXb5NTa49PZ4tLY4dHY4NHX4NDW38/V3svV4c7U3c3U3czT3MzS28vR2tav+8+h+8Ht9Mrd/crQ2cnP2cjP2MfN1sbM1sXL1cTK1MPK08LI0sHH0cTGyr7Fz77EzrzCzLi+yLa9x7W8xrS7xbC3wbC2wVHM4SLFXga21K+1wK60v620vquyvauxvKmvuqivuqast6SrtqKptKGos6Cmsp+msZyjr5yirpuirZqhrJmgrJifq5edqZadqZWcqJSbp5OZpZKYpZCXo4+Woo6VooyTn4uSnomQnYmPnIiPm3ao+W6j+GOb+F+Z+E+P94SLmISLl4OKl4GIlX+Gk32EkTyC9juC9vR/f/N4ePN3d7t7+fFhYfBVVahV9/BLS+9ISO9GRu9ERHqBjnd+jHZ9i3V8inR7iXJ5h3F5hnF4hnB3hW92hG10gmpxf2hwfmdufGVse2JpeGFod15mdV5ldF9kbl1kc1xjclticVpicV1hbFlhcFlgb1hfblRbalJZaVFZaFBYZ1BXZ09WZk1UZExUY0tTY0tSYkpRYUlQYEhQYEdPX0ZOXkZNXUVMXERLXENLW0JKWkFJWUFIWUBHWD9HVz1FVT1EVThAUTg/UDc+TzY+TjU9TjQ8TTNBVTM7TDM6SzI5Sy42SC01RiszRCgwQScvQSYuQCUtPyUsPiQrPSMrPSIqPCEpOyAoOiAnOh8nORsjNhsiNRoiNBggMxcfMhYeMRYeMBUdLxQcLxEZLBEYJwAAAAAAAAAAAAAAAAAAAAj/APcJHEiwoMGDCBMqXMiwoUOC+iJKlPiwYsUCGDNmtMixo8ePIEOKHEmyZMmJKFOabKixpcuVMGPKnEmzpk2IKXOivOmy58ubQIMKHUo0pM6jE2v6XKqxqNOnUKPSREo14kymWDFK3cq1q9eDVcPGzEr2q9mzaG+GXbuSrNu0cOPK7bi2bkm3eOfq3ct3X92/I/EK7ku4sMEATv8qDim48c0aiQxLhmliqGLAIBsPtslosmfDlxd71Oy4JqXPqPlWzbVli4DWtDB3JL2ZpqLIqXPDresg9EfaeXULH97wb2/fHIHXltmZuHOEJYIaD61vtvK3NBs93y4QsWXe1K1f/89qcxH380KnI7c4viz695/VXxbffin8+5Lli2Zfnyn+/31Rt99F/dkH4IFyCSgbgQX2hOCDaSloV3INOgjhhV9JWNVvFTaF4YdcaUgVhx1qBeKJUImIFIklouhiYiqqlFmLL9aYXow7zdihjTwChSNFIu3Y45A1/XhXgUQmOZWKbdWn5JMyiTjWeFBWCZOEVyln5ZYmCagUbVyGSdJ6NJEm5pkjTRhUcGi2KdJRURno5px01mnnnXjmqeeefPbp55+ABirooIQWauihiCaq6KKMNuroo5BGKumklFZq6aWYZqrpppx26umnoIYq6qiklmrqqaimquqqrLbq6quwxv8q66y01mrrrbjmquuuvPbq66/ABivssMQWa+yxyCar7LLMNuvss9BGK+201FZr7bXYZqvtttx26+234IYr7rjklmvuueimq+667Lbr7rvwxivvvPTWa++9+Oar77789uvvvwAHLPDABBds8MEIJ6zwwgw37PDDEEcs8cQUV2zxxRhnrPHGHHfs8ccghyzyyCSXbPLJKKes8sost+zyyzDHLPPMNNds880456zzzjz37PPPQAct9NBEF2300UgnrfTSTDft9NNQRy311FRXbfXVWGet9dZcd+3112CHLfbYZJdt9tlop6322my37fbbcMct99x012333XjnrffefPf/7fffgAcu+OCEF2744YgnrvjijDfu+OOQRy755JRXbvnlmGeu+eacd+7556CHLvropGNdRumop27W6aq37vrrsMcu++y012777bjnrvvuvPfu++/ABy/88MQXb/zxyCev/PLMN+/889BHn/kKETthFglFd9KBJkVbosI+GHgy9AgXCITJ0SMIjUn6+3RigdAktDAQB9wz3IT0+Oev//789+///wAMoAAHSMACGvCACEygAhfIwAY68IEQjKAEJ0jBClrwghjMoAY3yMEOevCDIAyhCEdIwhKa8IQoTKEKV8jCFrrwhTCMoQxnSMMa2vCGOMwhxKiAjGcMwwggKQSCWv7ArFPsQxls2AcbXjE0d7hgHy4Ih1NYURRuqIsZdJBAHeAhFCoWxA8To8IvnAGJdsAnEEFZxbAmEYN9YGEaQ/PFHPZRCkMURQifsYazrjCNarTiiUJxRMMCAgAh+QQBLQD/ACwbAAoA4QDOAYf9/f7/+/v4+//4+vz2/P3w+/zq+vD8+f/z+P769f/97e3o+e7x8fLn7/7i6PD84OD82tr819f71dXq1f370ND6xsb6vr74sbH4q6v4qqr1ngv2k5P1i4v0goLY9eLa5/3g5u7Z5v3f5e3e5OzU5P3d4+vc4uvb4erb4enP4f3Z3+fY3ufX3ebW3OTP4P3N3/3V2+TU2uPT2eLS2OHR2ODR1+DQ1t/P1d7L1eHB7fTJ8djI8NfG8NXD8NTK3f2/7tC068m068iu6sSn6L+N4ax63J5y2L9t2ZVg1ovO1N3N1N3M09zM0tvL0drK0NnJz9nIz9jHzdbGzNbFy9XEytTDytPCyNLBx9HExsq+xc++xM68wsy4vsi2vce1vMa0u8Wwt8GwtsGvtcDWr/vPofuutL+ttL6rsr2pr7qor7qmrLelq7ekq7aiqbShqLOgprKfprGcoq6boq1T0oFS0oE7zHB2qPmaoaxuo/iZoKyYn6uXnamWnamVnKiUm6dfmfiSmKWQl6OPlqKOlaKMk5+Lkp6JkJ2Jj5yIj5uFjJmEi5iEi5eDipeBiJV/hpNemPhPj/c8gvY7gvYswdszymsqx2Qox2ImxmEjxV8ixV4GttT0f3/zeHjzd3e7e/nzcXHyYmLxYWHwVVWoVffwS0vvSEjvRkbvRER6gY53fox2fYt1fIp0e4lyeYdxeYZxeIZwd4VvdoRtdIJqcX9nbnxlbHtiaXhhaHdeZnVeZXRfZG5dZHNcY3JbYnFaYnFdYWxZYXBZYG9YX25UW2pSWWlRWWhQWGdQV2dPVmZNVGRMVGNLU2NLUmJKUWFJUGBIUGBHT19GTl5GTV1FTFxES1xDS1tCSlpBSVlBSFlAR1g/R1c9RVU4QFE4P1A3Pk82Pk41PU4zQVUzO0wzOksyOUsuNkgtNUYrM0QoMEEnL0EmLkAlLT8lLD4kKz0jKz0iKjwhKTsgKDogJzofJzkbIzYbIjUaIjQYIDMXHzIWHjEWHjAVHS8UHC8RGSwRGCcAAAAI/wD/CRxIsKDBgwgTIvTHsGFDhRAjSvyXqaJFixMzatzIsaPHjxsdihwJsuPFkyhLqlzJsmXLkTBJukSIsmbKmThz6mQZs6fDnQJtCr0ItKjRowV9KmW4c6jTikijSnW5tGrOp1inat0asqpVl1jDch1L1qDXsy3Dqi3LluvZtyvVym1LF+nbuyWdFvGg40cduZnqCt55Fy7IoUh2VMqEhAfgwZCpFjZscmiPORaHXHocuTPIpb+wYAEgWhdljk4XWAJ80rPrjmcZTP7o1MBq1hhf6wQg9a3s2aid6qBTEZMQ3LpzPuode7K/ykOP9Fh9JAjy5NgXNge+ESsRDzuAUP+6nr3ln6i+nUPHvba8e4HpuWtkz/l9+fiF19N/at+9c7zB7ZdVf9n9d1pGAopFIHYGohVggkMtWGCDStEGoVASTkhhTxZeWFOGDG7IoUce2gRiiCKKlFeJRJ2YXIoydchiYC6+CCNTKs1IY402pphWiTzeJ+JMHgbpH4VXJWjkew02td+S9v1XFH1Q9iefk/VVGaVXU7WnZYYjjoXhl2SWaeaZaKap5ppstunmm3DGKeecdNZp55145qnnnnz26eefgAYq6KCEFmrooYgmquiijDbq6KOQRirppJRWaumlmGaq6aacdurpp6CGKuqopJZq6qmopqrqqqy26uqrsMb/KuustNZq66245qrrrrz26uuvwAYr7LDEFmvsscgmq+yyzDbr7LPQRivttNRWa+212Gar7bbcduvtt+CGK+645JZr7rnopqvuuuy26+678MYr77z01mvvvfjmq+++/Pbr778AByzwwAQXbPDBCCes8MIMN+zwwxBHLPHEFFds8cUYZ6zxxhx37PHHIIcs8sgkl2zyySinrPLKLLfs8sswxyzzzDTXbPPNOOes88489+zzz0AHLfTQRBdt9NFIJ6300kw37fTTUEct9dRUV2311VhnrfXWXHft9ddghy322GSXbfbZaKdNsRFqt73tJG7HLffcdNdt991456333nz34+3334AHLvjghBdu+OGIJ6744ow37vjjZ3IAbwbuUvBPBe1u4K4FD/yjAOTlfUJQ55WDAvrpqKeu+uqst+7667DHLvvstNdu++2456777rz37vvvwAcv/PDEF2/88cgnr/zyzDfv/PPQRy/99NRXb/312Gev/fbc7+4ADLnU48A/LRiTjTEtDAoInA5ggwg948OyyD+MuFKuA0n8A/8/4yzxDxPiOBM4GOWA8e1PHiD4BwjicT8Djg+BDkhgA/U3vv79L4DkKiAF/yE/+r1iUNtIyBrMVEAH7K9850ufVBJRq4AAACH5BAEtAPsALAQABAD4ANYBh/3+//z8/P/7+/j7//j6/Pb8/fD7/Or68Pz5//P4/vr1//3t7ej57vHx8ujw/uXu/uLo8Pzi4vzd3fza2vzX1/vV1erV/fvS0vvOzvrGxvrDw/m5ufizs/iurvirq/iqqvWeC/aZmfWNjfWLi/SCgtr15NX04Nrn/eDm7tnm/d/l7d7k7N3j69Tk/dzi69vh6tnf59je59fd5tbc5M/h/c/g/c3f/dXb5NTa49PZ4tHY4NHX4NDW38/V3svV4cHt9Mnx2Mjw18fw1sbw1cTw1MLv08rd/b/u0LTrybTryK7qxKfov43hrHrcnnXX52/Zlm3ZlWHWjF7Vis7U3c3U3czT3MvR2srQ2cnP2cfN1sbM1sXL1cTK1MPK08LI0sHH0cTGyr7Fz77EzrzCzLi+yLa9x7W8xrS7xbC2wa+1wKuyvdav+8+h+6mvuqivuqeuuaWrt6SrtqKptKCmsp+msZuirZqhrFPSgVLSgTvMcHao+W6j+JmgrJifq5edqZadqZWcqJKYpZCXo4+Woo6VoouSnomQnYmPnIiPm4eOm4SLmISLl2Ob+IGIlX+Gk1+Z+F6Y+E+P9zyC9juC9izB2zPKayrHZCjHYibGYSPFXyLFXga21Lt7+ahV9/R/f/N4ePN3d/lzFvNxcfJiYvFhYfBVVfBLS+9ISO9GRu9ERHd+jHZ9i3V8inR7iXJ5h3F4hm92hG10gmdufGVse2JpeGFod15mdV5ldF9kbl1kc1xjcl1hbFticVpicVlhcFlgb1deblRbalJZaVFZaFBYZ1BXZ09WZk1UZExUY0tTY0tSYkpRYUlQYEhQYEdPX5o0EkZOXkZNXUVMXERLXENLW0JKWkFJWUFIWUBHWD1FVThAUTg/UDc+TzY+TjU9TjQ8TTNBVTM6SzI5Sy01RiszRCgwQScvQSYuQCUtPyUsPiQrPSMrPSIqPCEpOyAoOh8nORsjNhsiNRoiNBggMxcfMhYeMRYeMBUdLxQcLxEZLBEYJwAAAAAAAAAAAAAAAAAAAAj/APcJHEiwoMGDCBMqXLiPgMOHECNKdPisosWLGJ8x3Mixo8ePIEOKHEky5MSTKCmGWsmyZUuNJWPKnEmzpk2SKXNKfOayJ0uYN4MKHUq0qEGdSCHy9NkTqNGnUKNKTTix5FKmL6dq3co1qESZV7GudNq1rNmzCyPODCuWLNq3cLuqXSs2a9y7eKPOpVt3bN6/gL0+tMkWq9vAiBN7hEi4r1/FkCOnHdzY8WHJmCEzrtz3cubPgDfXLMzUM+jTcUXTJO3TNOrXZlWvzUi74kwTsHPPlG2Ud0gpQgRG0Q3VwV/fRJF/LEJ86oPjlD0GwBm9ufWtyoVmv34XQOjqT7dz/x9vU3x58COJCHxCvv1R9EXNcyzhPigj6A6nyq/PfzH85P/1JyBI++0W4IAIblSgTAsm6GBDBwqW34MUKhjhTQ1WKGCG1E2o4YfveQgVhyC2R6JIJ5bIXYoEXqjigCx+FOOLus3YkY00voajhSLmSOGODAHpY2ZCKlTkkJIdGSIBSH6oZEFPNpnYXgC6KKWJT1J55YNa1tTllgl+heGXYCJYlYFklmlmUmyipKaKbcbZ45tOypkUnUPaeRKefPbp55+ABirooIQWauihiCaq6KKMNuroo5BGKumklFZq6aWYZqrpppx26umnoIYq6qiklmrqqaimquqqrLbq6quwxv8q66y01mrrrbjmquuuvPbq66/ABivssMQWa+yxyCar7LLMNuvss9BGK+201FZr7bXYZqvtttx26+234IYr7rjklmvuueimq+667Lbr7rvwxivvvPTWa++9+Oar77789uvvvwAHLPDABBds8MEIJ6zwwgw37PDDEEcs8cQUV2zxxRhnrPHGHHfs8ccghyzyyCSXbPLJKKes8sost+zyyzDHLPPMNNds880456zzzjz37PPPQAct9NBEF2300UgnrfTSTDft9NNQRy311FRXbfXVWGet9dZcd+3112CHLfbYZJdt9tlop6322my3jaQ+cMct99x00y1u3Xjnnbe3evf/7Tfc2/4tuN/Y1k2T4dXafZPi0849lOONy10U5NBSTpTlzUoOlebPcm6U58yC/nncnZMulejJon656Zmzvrnry6q+kBMjyW6s7UHhTqzuNvEurO+Hw64s8DMR/6vxMSHfq/IkMb+r8yJBn6v0IFF/q/UeYV+r9hxxP6v3DIEfq/gKkf+q+Qih36r6BrG/qvsEwZ+q/ALRf6r99puKv/Cp87864M7aHwBbN8DXFTB2/ntcAo8lv/zdb4G9g+Dt3Ic5Ah5wcQ6cn/kqWDrxMS5yHIzeB6k1uBLiLXAmNCHfUii4u7EQcW6LoQxnSMMa2vCGOMyhDnfIwx76MGIi+KGg/zCwDw30KwT+2oAEBNaBfXFgIBH41wWESMUqWvGKWMyiFrfIxS568YtgDKMYx0jGMprxjGhMoxrXyMY2uvGNcIyjHOdIxzra8Y54zKMe98jHPvrxj4AMpCAHSchCGvKQiEykIhfJyEY68pGJhMBC4OEqCNzgFvGQZFfCUIiDUFIgmgTlJBESSoR8kiEQSGUqDcLJg6hylZ5UiCM6Ug9q2HIRmYHANRABj1LC5ZSl9KVBTlkQYRaEmArRpCo5YsxjKgSZz0QNBKawj15KBQLwgMU1rJEFbEJAB8KgRjN44E0efCMM2ATlJ7O5zW6m0prv1CY3w4CNcCjim+EcZznPSf9Pe+6jB8a4Bi/eAQEc9AIa1jDDPphBkHW2ohreoEMo4WGLREwhGdZIBjXZyc2LZnQKqshHMwyChlieZpXWjAoE7GEHCPxhGN7MRR8gEIhZYJMF0lCDJD+Zzn2w1KUwfackU/nTl84CDTlQBwRkSlObwgOnOj1qUvfBCz/sYw73gEAtzrAPLHRjHzJoaCrroYh9aMEcobTHG/bhC0DsAxC98Kkd9vHStr41rtDcRyt40QVnnnSnzRQKBOrBAgi4gB3eREdhUTADbNJCEPvYKSjlIRDCGhaxQo3sYAt7WBkQ4hXzgIBiIcBYx0IWAp4FLQTO4YJ9qIAeq7UlNcaBAs3/AhYC97iBQDKpynnUNh2tdUE69kHYfRwWuMYd7ilZQQ06CKQKsogFQWppSy/kErDX9K1hy+HNdbgAlvbIBi0iuw/K7uMG9xCIdl3A3cym0rfGLccyCGEFeUDAu0NdqXgjO9/67qMdrWVBPe77gn2gIA3DTKV5qzlRgagjuMOFL3sfnNxqImQFhgBGQ6WJXancQw4uvYU3i1EHCAzCFdhEgTMIkcpzhGEfhrCHQD4cYlXCE7cg/sMt3jEDLuADAiQ2MYrhoWIW89jH+xhGHfZhB3tAIBgzjYMy9hEDsfaUwQP5pC+s6gdf7OPDdL3FlvfR5fLWtiB8IAYc/AoaGwdWkijwuIU1jLEDb26BGtUwxg28uQNymAECdBDHNF6xTjnT2c02NvQOViGOXwD4znnecy/7bAZGO9oFWbCGNV5B0CsooxrR0MI+RpplyQokpRbeRxWUYQ1lUKGail51q1+NjGMYhBBn3jCe8tqRiQqTmLwuZn4Pcosx7KMM1shVsDfi62HqeiGvNCYZrMGMaYjhQwEBACH5BAEtAPoALBsABABRAdYBh/3+///89vz8/P/7+/j7//j6/Pb8/fD7/Or68Pz5//r1//758f726fP4/uj57v705PHx8v3pyP3px+fv/uLo8P3nw/znwvzlvfzg4Pza2vzX1/vV1erV/fvS0vvOzvrGxvrDw/nBYvi2SPe2R/izs/iurvirq/ajGfWhFPWgEPWeC/aTk/WLi/SCgtj14uDm7tnm/d/l7d7k7N3j69Tk/dzi69vh6tnf59je59fd5s/h/c/g/c3f/dbc5NXb5NTa49PZ4tHY4NHX4NDW38/V3svV4cHt9Mnx2Mjw18bw1cPw1Mrd/b/u0LTrya7qxJrltnrcnnXX52/Zlm3ZlWDWi87U3c3U3czT3MvR2srQ2cnP2cfN1sbM1sXL1cTK1MPK08PJ0sHH0cTGyr7Fz77EzrrAyra9x7W8xrS7xbC2wa+1wNOo+6uyvamvuqivuqeuuaWrt6SrtqKptKCmsp+msZyirpuirZqhrFPSgTvMcHao+W6j+JmgrJifq5edqZadqZWcqGOb+JOappKYpZGYpJCXo4+Woo6VoouSnomQnYmPnIiPm4eOm4SLmISLl4GIlX+Gk1+Z+E+P9zyC9juC9irHZCjHYiXGYCLFXga21Lt7+ahV9/R8fPN3d/lzFvNxcfJiYvFhYfBVVfBLS+9ISO9GRu9ERHd+jHZ9i3V8inR7iXJ5h3F4hm92hGVse2JpeGFod2Bndl5mdV5ldF9kbl1kc1xjclticVpicV1hbFlhcFlgb1deblRbalNaalJZaVFZaFBYZ1BXZ09WZk1UZExUY0tTY0tSYkpRYUlQYEhQYJo0EkdPX0ZOXkZNXUVMXERLXENLW0JKWkFJWUFIWUBHWDtDVDhAUTg/UDc+TzY+TjU9TjQ8TTNBVTM7TDM6SzI5SzA4SS01RiszRCgwQScvQSYuQCUtPyUsPiQrPSMrPSIqPCEpOyAoOh8nORsjNhsiNRoiNBggMxcfMhYeMRYeMBUdLxQcLxEZLBEYJwAAAAAAAAAAAAAAAAAAAAAAAAj/APUJHEiwoMGDCBMqXKivgMOHECMWYEixosWLGDNq3Mixo8ePIEOKTCix5MORKFOqXMmypcuXLE2ahEmzps2bOHPelFlSp8+fQIMKxamiqAqeDocqXcq0qVODRo3yfEq1qtWrGKNqLai1qEysYMOKbdq1bFGBZmeOXcu2rUuzcOMelei2rt27GuXqLUsXr9+/gPXtHRy1b+DDiMMSXuwVYuLHkJ0yZhwxsuXLPidTdoy5s+eWmjef/Ey69Ee5ASpYiBAi9NzRH12Y5ghjNla5C4qisNCaMEsqSARSsZ1xAnGqenMXHSGB8UolBJ1cOl7ROHWyuI2mYOD8uvfvBJMb/0XxoDv488f3Klcx4sLklXgEYkKPMBL9oOqLnogg4r1K6AI1cd+AS+2VmgUS9GYeSk/Ipk8eBEaIn2u+SWhhYhRWeOGGf2U4GIcg4uXhXiGW6NaIepmo4lgoyrXii2C1aBaMNFolY1k15ijZjVvp6KNSPBr145BCBXkWkUhmxmOSTOp0Y5NQEoVilFTaNGKVWNKUYZZcvuRal2CC5l+YZKqkYZlomjljmmy26eabcMYp55x01mnnnXjmqeeefPbp55+ABirooIQWauihTC2j6KKMNroMomUu48mklFZa6aOQhimppZxOimmmXW7aqaWfgpqlqKNSWqqpVaKaqiersv8KYz601lprQa6mGqusJdrq668C5Trqrrxu+OuxvwrbKbHFSojss7UqyymzzQ4I7bXSkloth9di++ql217Yrbffehqus+NCmy2451qbrrrlmtsufe9i6+i9is5Lb7316isuv/z6iy60uYghhgAG09KvwAS+CwHA+TDsbroPQyzxvhRDHPHF59VbMcAcd+ywxiGD5zHJJXt3ssUpX6dxwC1T9/LCMRM387s1y3zztTnrvPOzPR/3M7RBCz00sEXbfLSvSRu99MZNK3101C4PTbXKO1/93c1am4xy11uDDDZ6OI/dMLJmp6322my37fbbcMct99x012333XjnrffefPf/7fffgAcu+OCEF2744YgnrvjijDfu+OOQRy755JRXbvnlmGeu+eacd+7556CHLvropJdu+umop6766qy37vrrsMcu++y012777bjnrvvuvPfu++/ABy/88MQXb/zxyCev/PLMN+/889BHL/301Fdv/fXYZ6/99tx37/334Icv/vjkl2/++einr/767Lfv/vvwxy///PTXb//9+Oev//789+///wAMoAAHSMACGvCACEygAhfIwAY68IEQjKAEJ0jBClrwghjMoAY3yMEOevCDIAyhCEdIwhKa8IQoTKEKV8jCFrrwhTCMoQxnSMMa2vCGODxgJnLIwx768IdADKIQ/4dIxCIa8YhITKISl8jEJjrxiVCMohSnSMUqWvGKWMyiFrfIxS568YtgDKOsWIC6NTTFBGLMGSdW0D0SYEAfDPBeJ773xjSyyYx2zKMe98jHPvrxj4AMpCAHSchCGvKQiEykIhfJyEY68pGQjKQkJ0nJSlrykpjMpCY3yclOevKToAylKEdJylKa8pSoTKUqV8nKVrrylbCMpSxnScta2vKWuMylLs32DoNQwHGEoIY23PATCvzSl/qAhEB6eRBmEuSYC3HmQKBpkTEgoiDGpIg0BQJNZWITIfSIhjgdwU1jZlNOQpDGC8IQDqf8kpnbHEg8qZmQedrEnstEZjP1Wf+nMNRBHzdoh00WkQ1suKEKxpiGMapAgXeY06GnwIcyGqoKaXiDDsdsqDn18Y5WUGMaWxhDNb7RCAoE4RfRUMYQNDoEboxBpCSlABGGQY1buIMCP8BFM6ZxBgokw5wN1QdFpbENOpTzHbJgBEIVytCOUkMfW9BHQhca0YkClQJp8CU+8SSIWNikHTkIgy10AQh9AAIXQTWmQzWqj3o0Qh9gKEdGe5nNetyBAn8AhivSAIR06KMWfaDAIFzR0Bk8gw2/5Gs6KHALP1BgDvagACzQQAEtaIMCOchmWunxVi6Uo5z1eAMFyGpWtNoVr8AgKwXOqtFfalYVt/jCMx36TTz/deEbQrDJLIDRBn2gowb6qAE60kqBeKhVIPbwgUDgMVeh/pIeM6BADdaRg0OwQh76OEd0X9CDhr6iEEKt7nUpYI4aUCAG8yCvOKMhjhc4V62/TO5yyymPF1Dgt8EdLnSlu47gSne4a9VHKqKBUX1cwRWtOGc4xQmGcm50Tji4BhpwooZfyCIdwBVucQXig8gGVR/GXWZzs1lf6ZIDGYfAQjz0oQ7zmrMe1niFQFCsYgqww7wzoAcF1GEDCrxADa51LTNX/E26Yji/+ihxDciB4f+21rlC1YcMEsELggR4mnjyRWBt0gNpyOAG7NCFH/ThB12QdwwUSEQ9jBkP9waY67ZCpWt85YDXWbijB164hz6EYQcKGGIVDX0BMw5BgTvnmQLA6PMd1tyLwMbhGBTAgWbpak+6ipnMutCHPej8h1mQmQJlLq59oUwBPgQDDrOlJz3lNAh5iJMYNnnENbKhiCscYxrHsAIF6AAOaLCCtsUgRmvZGueNvmMW0xiGEFABjl3cuAvRkMYwfKBRIYzjDMx2dg22MI1psOKmWTiGNJzBBQpY9bgffiZHhWprXFuBo8hWdrtzTYFgA1Woh3DvbPnZslVvJN3rpqa/FzKLMujDDNMoJ5QvN/CMAJyu6sYIwpMBDTI4+Jw9CwgAIfkEAS0A+wAsGwATAOEAxQGH/f7///z2/Pz8//v7+Pv/+Pr89vz98Pv86vrw/Pn/+vX//vnx/vbp8/j+6Pnu/vTk8fHy/enI/enH5+/+4ujw/efD/OfC/OW9/ODg/Nra/NfX+9XV6tX9+9DQ+sbG+sPD+cFi+LZI97ZH+LGx+Kur9qMZ9aEU9aAQ9Z4L9pOT9YuL9IKC2PXi2uf94Obu2eb93+Xt3uTs3ePr1OT93OLr2+Hq2uDo2d/n2N7n193mz+H9z+D9zd/91tzk1dvk1Nrj09ni0djg0dfg0Nbfz9Xey9Xhwe30yfHYyPDXxvDVw/DUyt39v+7QtOvJrurEmuW2etyecti/bdmVYdaMXtWKztTdzdTdzNPcy9HaytDZyc/Zx83WxszWxcvVxMrUw8rTw8nSwcfRxMbKvsXPvsTOusDKtr3HtbzGtLvFsLbBr7XA06j7q7K9qrC7qa+6qK+6p665pau3pKu2oqm0oaezn6axnKOvm6KtmqGsU9KBO8xwdqj5bqP4maCsmJ+rl52plp2plZyokpilkJejj5aijpWii5KeiZCdiY+ciI+bh46bhIuYhIuXgomWgYiVgIeUf4aTYZr4Xpj4T4/3PIL2O4L2KsdkKMdiJcZgIsVeBrbUu3v5qFX39Hx883d3+XMW8WFh8FVV8EtL70hI70ZG70REd36Mdn2LdXyKdHuJcnmHcXiGb3aEa3KAZ258ZWx7Yml4YWh3XmZ1XmV0X2RuXWRzXGNyW2JxWmJxXWFsWWFwWWBvV15uVl1tVFtqUllpUVloUFhnUFdnT1ZmTVRkTFRjS1NjS1JiSlFhSVBgSFBgmjQSR09fRk5eRk1dRUxcREtcQ0tbQkpaQUlZQUhZQEdYPkZWOEBROD9QNz5PNj5ONT1ONDxNM0FVMztMMzpLMjlLLTVGKzNEKTBCKDBBJy9BJi5AJS0/JSw+JCs9Iys9Iio8ISk7ICg6Hyc5HiY4GyM2GyI1GiI0GCAzFx8yFh4xFh4wFR0vFBwvERksERgnAAAAAAAAAAAAAAAAAAAACP8A9wkcSLCgwYMIEypcyLChw4cQI0qcSLFhi4oYM2qUSGXglI0gQ4osKGmkyZMoU6pcybKly5cwY8qcSbOmzZs4c+o0WXKnT4RSfgodSrSoUYKRjipdyrSp06dQo0qdSrWq1atYs2rdyrWr169gw4odS7as2bNo06pdy7at27dw48qdS7eu3bt48+rdy7ev37+AAwseTLiw4cOIEytezLix48eQI0ueTLlyxgKYM2veXMDyVc6gM3u2Gjr06KqlQZ+mmprz6qmtN78WWrpgbM2zdd7GLHA379w2fQvHDZzm8OOdi8tEflx5TObNnbuEHl36SurVraPEnl37SO7dvYf/BG9a/HTy5c1fR69a/Xr2st2nhJ9e/nf6ru2bxJ9fv0j+8fk3HoCiCTgggckZuBGCvymoEYMJOogRhBIuSGCFFgKI4YMXbngZfx5yiF+IIrJHYobknQgSeioeSF2L/70IY4zIzbhfeDauuFuOLNXG449ABinkkEQWaeSRSCap5JJMNmnkMlBGKeWUyzj50DKfZKnllltWaWVDWHIpZpZefrlQmGNyWaaZCaGZppZrsnmQm29+EqeS+uSpp54F0fnmnUbuKeigAvmZJqBDDqrooIaOiWiQi0aqZ6NiPvqjpJhSquaRmGZaZ5eBdiqppqASKaqnn5Jp6qmjpqqqkKxm/0rlrFAmGmusS96qK56Y5iKGGAL8SguuSbIKga76FGsssslyuiyySMZ6LLTOnjrtrtWKeu2t0T6LbajMstptuKeOS26nyp4rKa/qRspuu4rmCi+h8s67Z5P28ulkvmbOK2e7cgp0bsADhUswQdQejHC5CifkbsMQRyzxxBRXbPHFGGes8cYcd+zxxyCHLPLIJJds8skop6zyyiy37PLLMMcs88w012zzzTjnrPPOPPfs889ABy300EQXbfTRSCet9NJMN+3001BHLfXUVFdt9dVYZ6311lx37fXXYIct9thkl2322WinrfbabLft9ttwxy333HTXbffdeOet995899/t99+ABy744IQXbrhMURyu+OKMN+7445BHLvnklFdu+eWYZ6755px37vnnoIcu+uikl2766ainrvrqrLfuelkdvE7WCCfT3rEntpfcASiy9+7778AHL/zwxBdv/PHIJ6/88sw37/zz0Ecv/fTUV2/99dhnr/323Hfv/ffghy/++OSXb/756Kev/vrst+/++/DHL//89Ndvpg29RHONHB8/0ggFVhjHx34gg320IRwhuwU92FCXOhCGAnSwhX9c0YqjuAIGFHDBO9JiDcfYwg4USEMHPaYFaEiDGWGYWEAAACH5BAEtAP0ALBsAFADhAMYBh/3+///89vz8/P/7+/j7//j6/Pb8/fD7/Or68Pz5//r1//758f726fP4/uj57v705PHx8v3pyP3px+fv/uLo8P3nw/znwvzlvfzg4Pza2vzX1/vV1erV/fvQ0PrGxvrDw/nBYvi2SPe2R/ixsfirq/ajGfWhFPWgEPWeC/aTk/WLi/SCgtj14trn/eDm7tnm/d/l7d7k7N3j69Tk/dzi69vh6tnf59je59fd5s/h/c/g/c3f/dbc5NXb5NTa49PZ4tHY4NHX4NDW38/V3svV4cHt9Mnx2Mjw18bw1cPw1Mrd/b/u0LTrybTryK7qxKfov43hrHrcnnLYv23ZlWHWjF7Vis7U3c3U3czT3MvR2srQ2cnP2cfN1sbM1sXL1cTK1MPK08PJ0sLI0sHH0cTGyr7Fz73Dzbi+yLa9x7W8xrS7xbC3wbC2wdOo+6+1wKuyvamvuqivuqeuuaWrt6SrtqKptKCmsp+msZuirVPSgTvMcHao+W6j+JqhrJmgrJifq5ieqpedqZadqZWcqJKYpZCXo4+Woo6VoouSnomQnYmPnIiPm4eOm4SLmISLl4GIlWOb+H+Gk1+Z+E+P9zyC9juC9izB2zPKayrHZCjHYiXGYCLFXga21Lt7+ahV9/R8fPN3d/lzFvNxcfJiYvFhYfBVVfBLS+9ISO9GRu9ERHd+jHZ9i3V8inR7iXJ5h3F4hm92hG10gmdufGVse2JpeGFod15mdV5ldF9kbl1kc1xjclticVpicV1hbFlhcFlgb1deblRbalJZaVFZaFBYZ1BXZ09WZk1UZExUY0tTY0tSYkpRYUlQYEhQYJo0EkdPX0ZOXkZNXUVMXERLXENLW0JKWkFJWUFIWUBHWD5GVj1EVThAUTg/UDc+TzY+TjU9TjQ8TTNBVTM7TDM6SzI5Sy01RiszRCgwQScvQSYuQCUtPyUsPiQrPSMrPSIqPCEpOyAoOh8nORsjNhsiNRoiNBggMxcfMhYeMRYeMBUdLxQcLxEZLBEYJwAAAAAAAAAAAAj/APsJHEiwoMGDCBMqXMiwocOHECNKnEixoaSKGDNqzPhko8ePIEOKHEmypMmTKFOqXMmypcuXMGPKJHhxps2ITW7q3MlTIpSBl3oKJQhpqNGjSJMqXcq0qdOnUKNKnUq1qtWrWLNq3cq1q9evYMOKHUu2rNmzaNOqXcu2rdu3cOPKnUu3rt27ePPq3cu3r9+/gAMLHky4sOHDiBMrXsy4sePHkCNLnky5suXLmDNr3sy5s+fPoEOLHk26tOnTqFOrXs26tevXsGPLnk27tu3buHPr3s27t+/fwIMLH068uPHjyJMrX868ufPn0KNLn069uvXr2LNr3869+80C4MOL/x9fwHs/8ujDm0+ffj178u7fi48vH3x09gXrz2+u3/75/uUtB+CA+yVH4IEBIofggQYuSKCCDj5oXIQMFkdhhcNdiKFwGrbHXIf4CQgieh+OCJ9yJnoIYYrjochiiw2+qF6MMiZ4XI0zrlijizjyuKOPLJYoo5Av8lekkUE6l+RzJk4HYnUaXkdhdg5uh6B3AJpHUIhadunll2CGKeaYZJZp5plopomYM2y26eabzpjnTCh01mmnnXF6N+edfNKZZ3d79nnnn9wFKmidhG5n6KGhJMocP5BGGmlBix7qKHKSZqqpQJUKemlxmoaqaad9fjqcqKhGSiqfpgaX6qurDv+a3KuwMoonprSmGuutxuVaq61+9uqrrsAGS9ywsMKpLJugIotsc85G++irvZBBhgDW4vLscsNCEC0/3Hb7Lbizivutcsh6e265vqorLbu5uussuua+i+u4w9KLr6/67ktruP6mOm3AqA5McKjQHrxpwgpL+lzDk0IH8XQKV0fwdf5mh+9263KXr5cFqynyyCSXbPLJKKes8sost+zyyzDHLPPMNNds880456zzzjz37PPPQAct9NBEF2300UgnrfTSTDft9NNQRy311FRXbfXVWGet9dZcd+3112CHLfbYZJdt9tlop6322mybZUnbcMct99x012333XjnrffefPe57fffgAcu+OCEF2744YgnrvjijDfu+OOQRy755JRXbvngopw8yuWcd+7556CHLvropJdu+umop6766qy37vrrsMcu++y012777bjnrvvuvPfu++/ABy/88MQXb/zxyCev/PLMN+/889BHL/301Fdv/fWRU6D9HPiYqT0O2dDjPQWy4CHPmWsMQ8H5dNkhGA3aYLG+a7EgJIZOgJBDDTX76IKWNo7RXj/mVybtaY99hzNDms4wkDLUJSAAIfkEAS0A+gAsCgATAPIAxwGH/f7///z2/Pz8//v7+Pv/+Pr89vz98Pv86vrw/Pn/+vX//vnx/vbp8/j+6Pnu/vTk8fHy/enI/enH5+/+4ujw/efD/OfC/OW9/ODg/Nra/NfX+9XV6tX9+9DQ+sbG+sPD+cFi97ZH+LGx+Kur9qMZ9aEU9aAQ9Z4L9pOT9YuL9IKC2PXi2uf94Obu2eb93+Xt3uTs3ePr1OT93OLr2+Hq2+Hp2d/n2N7n193mz+H9z+D9zd/91tzk1dvk1Nrj09ni0tjh0djg0dfg0Nbfz9Xey9Xhwe30yfHYx/DWw/DUyt39uOzLrurEj+Kucti/bdmVYNaLztTdzdTdzNPcy9HaytDZyc/ZyM/YyM7Xx83WxszWxcvVxMrUw8rTwsjSwcfRxMbKvsXPvsTOvMLMt77ItbzGtLvFsbjCsLbBr7XA06j7rbS+q7K9qa+6qK+6p665pqy3pKu2oqm0oaizoaezoKayn6axnqWwm6KtmqGsU9KBO8xwdqj5mJ+rl52plp2plZyolJunkpilkJejj5aijpWijJOfi5KeiZCdiY+ciI+bho2ahIuYhIuXgYiVgIeUf4aTYJn4T4/3PIL2O4L2KsdkKMdiJcZgIsVeBrbUu3v5qFX383p6+XMW82pq8WFh8FVV8EpK70ZG70REeoGOd36Mdn2LdXyKdHuJcnmHcXiGcHeFb3aEbXSCbHOBanF/Z258ZWx7Y2p4Yml4YWh3XmZ1XmV0X2RuXWRzXGNyW2JxWmJxXWFsWWFwWWBvWF9uV15uVFtqUllpUVloUFhnUFdnT1ZmTVRkTFRjS1NjS1JiSlFhSVBgSFBgmjQSR09fRk5eRk1dRUxcREtcQ0tbQkpaQUlZQUhZQEdYOD9QNz5PNj5ONT1OM0FVMzpLMjlLLjZILTVGKzNEKDBBJy9BJi5AJS0/JSw+JCs9Iys9Iio8ISk7ICg6ICc6Hyc5GyM2GyI1GiI0GCAzFx8yFh4xFh4wFR0vFBwvERksERgnAAAAAAAAAAAAAAAAAAAAAAAACP8A9QkcSLCgwYMIEypcyLChw4cFnwhMArGixYsYM2rcyLGjR4NQkAgM+bGkSY+RTqpcyZIgk5YwY8qcSbOmzZsK+eDcybOnz59AgwodijAl0Ywhji45yrSp04dN9CFZsucpUaNWs2rdyrWr169gw4odS7as2bNo06pdy7at27dw48qdS7eu3bt48+rdy7ev37+AAwseTLiw4cOIEytezLix48eQI0ueTLmy5cuYM2vezLmz58+gQ4seTbq06dOoU6tezbq169ewY8ueTbu27du4c+vezbu379/AgwsfTry48ePIkytfzry58+fQo0ufTr269evYs2vfzr279+/gw4v/H0++vPnz6NOrX8++vfv38OPLn0+/vv37+PPr38+/v///AAYo4IAEFmjggQgmqOCCDDbo4IMQRijhhBRWaOGFGGao4YYcdujhhyCGKOKIJJZo4okopqjiig864+KLMMboTE0F1GjjjTgWcJwznfTo448/zkhTjkTauCOQSPoo5ExFFnlkkkguKVOTRD4JZZA0UomjlVf2KGVMWm6JWz5klllmQTx2qaRHTRYU5o22mSnnnAKlqWYnX1r0Zo0C7cnnbHMGOqedaub5kJ+IwimboIyWSWiXhjaU6KQ6xtbopY9eGelClE5q6aWNZgrlpgl16ulroGJ6p5cVmXpqa6mq/7oqqQa5+upqscp6J60E2XprarliKuOwLjrk66+oBavsRsc6SZuy0GbUbJuAXsoLGGAIgO0twUo7bZXVpgoBtPl4+62Yn8Y6LrkXnessbMGuG62e7ua4aK7yLktvvYrCiy+55e7L75/+qgtwuwMbma64Bws88L0A54pwwpUWHHGqEycM8cWgZvzwxhwLai6/z4bc6Mj1lmyyyBhRXNvKgTJL8sswyylzynHWTGZHON+m80fn7gazSdP2ZrJKx/7GMUu2BhcxTKYOxy6YyAIncZZvLseoT9Sy6PXXYIct9thkl2322WinrfbabLft9ttwxy333HTXbffdeOet99589//t99+ABy744IQXbvjhiCeu+OKMN+7445BHLvnklFdu+eWYZ6755px37vnnoIcuul2ZjG766ainrvrqrLfu+uuwxy777LTXbvvtuOeu++689+7778AHL/zwxBdv/PHIyxeKgyoMJIqDnDQYfYKeDLT8g58kr/323Hfv/ffghy/++OSXb/756Kev/vrst+/++/DHL//89Ndv//3456///vz37///AAygAAdIwAIa8IAITKACF8jABjrwgRCMoAQnSEG0vIMgFCBOG8RBDWqcwikZhEQGBXLBgYywISUUyAkrEoZDmHCFC0mhPmAICQwqhB4dpEYjKMBDHoIFEIboIQj/9fGOE8oQhgo54k2USBAmIsSJYXkEHYRIE3BcgQLMeAUF1vALH+wCGtYogz4UoY1suKEU+GhGD2WoD1ZcwxpZCAM2vMEICgRBGNRoxhAoUMQhcCMMcqQjBYhgjGvowh0U8CIYy4BFIZbwHaioBjfs0EM+1kIRUUiGNZIRBT66EY6Z3GQU0KjGSuoDDTYkYirF4gpZYMMYW6jJKwDRgmdUgwKkCAQtzEABK2xDH+zAwRdyQUQf8pEg9ciDPv4wjFig4QfooAAu+kABQcSCjzGQBhv04Uxo6kMXfqBAHexBgV32chsUwMEMM1hCetRRC+QwZj3eoI9eAIICgNgFBZJJ/wFm2lMf+TymMQWCCl10QYU8hCJYWoEICtxBGjWBwyzGsApm4AAaRChHDsPRAlsMow3s9KEqB0KPGOhjBurAQSFUIQ8KmCMGFGgBD/g4i0FkUKUs1Uc5ZkCBF8yDAhrtIEcreUx92KMHGYSHSOXRAn2cg6czOAcFSkoBlD5VIFK9IA9PQQ07CGQKsGgFQnHYQS8QFSxYaEFM24FEltRgG4aYQynkcA0KpIMGMU0DD9MgjFoUEyFMPek4llEIKsTDrjzN4D6xMQuBENaw+lgHT2NAD7vitQV6VSw7BRKPGf61IOiAqlSZWtVxhBarAlXsQGCACGAgVKFfAQYd9HEGiPrOhIfLaAYQ2jCNU1AgGNSMgzJ4UA0Y2GAdFIhHUw9iDzks0xbu4AEX7kGBYuCBAoRIBR9rWQh9RHe6+hjGdfNQj98GVxkUuME6R6rVzxKkF+H0Qy8o0Nx+2gK++pBvctWqWX3kgRhwQGhRVciTbHSkC9igxjJiSRMKLOIb6cQHGihQBWVUIxpaoIAjsqGNRFAAGcdIiC2sYQwhmOIbvpDsFqhRDWMgtYhCEEcZTpziGWTBGtZQBSIrfOEMl3KzqgypQaagDGsoQwp8HHGJiayPI3/4GMbMYCGWu17YjoaNq6yILcagDzJYI8rmwbIJMeJlZkxDDGcdTEAAACH5BAEtAPsALAoAEwDyAMcBh/3+///89vz8/P/7+/j7//j6/Pb8/fD7/Or68Pz5//r1//758f726fP4/uj57v705PHx8v3pyP3px+fv/uLo8P3nw/znwvzlvfzg4Pza2vzX1/vV1erV/fvQ0PrGxvrDw/nBYvi2SPe2R/ixsfirq/ajGfWhFPWgEPWeC/aTk/WLi/SCgtj14trn/eDm7tnm/d/l7d7k7N3j69Tk/dzi69vh6tnf59je59fd5tbc5M/h/c/g/c3f/dXb5NTa49PZ4tHY4NHX4NDW38/V3svV4cHt9Mnx2Mjw18bw1cPw1Mrd/b/u0LTrya7qxJrltnrcnnLYv23ZlWDWi87U3c3U3czT3MvR2srQ2cnP2cjO18fN1sbM1sXL1cTK1MPK08PJ0sHH0cTGyr7Fz77EzrrAyra9x7W8xrS7xbC2wa+1wNOo+6yzvquyvamvuqivuqeuuaWrt6SrtqKptKCmsp+msZ2ksJuirXao+VPSgTvMcG6j+JqhrJmgrJifq5edqZadqZWcqGOb+JKYpZCXo4+Woo6VoouSnoqRnomQnYmPnIiPm4eOm4SLmISLl4GIlYCHlH+Gk1+Z+E+P9zyC9juC9ijHYiXGYCLFXga21Lt7+ahV9/R8fPN3d/lzFvFhYfBVVfBLS+9ISO9GRu9ERHd+jHZ9i3V8inR7iXJ5h3F4hm92hG10gmhvfmVse2RremJpeGFod15mdV5ldF9kbl1kc1xjclticVpicV1hbFlhcFlgb1deblRbalJZaVFZaFBYZ1BXZ09WZk5VZU1UZExUY0tTY0tSYkpRYUlQYEhQYJo0EkdPX0ZOXkZNXUVMXERLXENLW0JKWkFJWUFIWUBHWD9HVz1FVThAUTg/UDc+TzY+TjU9TjQ8TTNBVTM7TDM6SzI5Sy41Ry01RiszRCgwQScvQSYuQCUtPyUsPiQrPSMrPSIqPCEpOyAoOiAnOh8nORsjNhsiNRoiNBggMxcfMhYeMRYeMBUdLxQcLxEZLBEYJwAAAAAAAAAAAAAAAAAAAAj/APcJHEiwoMGDCBMqXMiwocOHBZ8IXAKxosWLGDNq3Mixo8eDRyoJRPKxpEmPkU6qXMmypcuXMGPKnEmz5kM9NnPq3Mmzp8+fQIMiTCk0Y4iiTIoqXcr0oZN9R5I2FRpoqtWrWLNq3cq1q9evYMOKHUu2rNmzaNOqXcu2rdu3cOPKnUu3rt27ePPq3cu3r9+/gAMLHky4sOHDiBMrXsy4sePHkCNLnky5suXLmDNr3sy5s+fPoEOLHk26tOnTqFOrXs26tevXsGPLnk27tu3buHPr3s27t+/fwIMLH068uPHjyJMrX868ufPn0KNLn069uvXr2LNr3869u/fv4MOL/x9Pvrz58+jTq1/Pvr379/Djy59Pv779+/jz69/Pv7///wAGKOCABBZo4IEIJqjgggw26OCDEEYo4YQUVmjhhRhmqOGGHHbo4YcghijiiCSWaOKJKDpYwIostuhiAfy9KCOLMc4oY402uohjjjTux6OO7dlY0I8trkfkigIdiSR6SjZZ5HlORgmjeVJGSWWVTpaHpZXjbclleF5++V2YYnpH5ozqnSkkk2reyGabQF4J54tQzkmnnHb2qGWeT+7J55J+/lnnn1MGyueggiJqZ3qEMprom3MamSd7iwbZJnxqykcmfV7ahyV+Uvp4JIBrpmjqqaimquqqrLbq6quwjv+lzKy01mqrMvwp08muvPbaK6776errsLsCq5+wxPpqbH7IJsvrsvg162wn0Kanz7XYYluQtM5WW1624IYrELfJeiteuOiGSy6x5oKX7rvYrjtsu97Ba6+8yppn773T/vrtvvDi6+94APPbb7EEFxzwwQiHp/C9t0Y867kPP6xexRhbay8uYYQhQMezWIyewhBgrM/IJJt8sr4pm3zewyW7zHLBMWc8M8A1V/xyyzb/q7LCO/9ccNBC74ty0fBqjPS7Si+N7sVOiwt11NmyR7W27V0NX9TyLU1f0fb9jJ/M+QH9H9Oxpq322my37fbbcMct99x012333XjnrffefPf/7fffgAcu+OCEF2744YgnrvjijDfu+OOQRy755JRXbvnlmGeu+eacd+7556CHLvropJdu+umop64qKAtuMlAoC3KioOwG0r4P66rnrvvuvPfu++/ABy/88MQXb/zxyCev/PLMN+/889BHL/301Fdv/fXYZ6/99tx37/334Icv/vjkl2/++einr/767Lfv/vvwxy///PTXb//9v1NAEDzBucCKNdLYAlMgsQ8K8E8g+hvIARuSQIEssCIUaKAYDPGQBu7jgQUkCAETEsEO1gMaIGxEVw5xin3QoRdM4Z8BB2JBDCqkhTWBIUFkiBAaeqUaXdiHDB4xE0VkAxtumEIx/6RRjCkYMIIXpAAp8pEMA54iGt6gQ0E6aEBVTEMaWhADNb7BCAoAoRfQSIYQjigEbohBi1ykwBCCMQ1bvIMCPrgFM6Rhhn0gA4FHdGI0tkEHKsIjFosQIhGNCA8rYlGQRVxiMjI4EDQgcH9hcUcjoOGLLMykHTgAQy1yAQgKAOIWeUziCilgD0bs4wvl2J/+ImiPPVDgD75oBRp+kA4K0KIPFBBEKy4oA2ewYR+ypCUFbOEHCszhHhSAxRn2gQVt7AMHeIRHBOthyi2UY5WkfAMFOOlJULZyH7Dk5D4+eUE8JvAUtvCCDbsSjzrsow7NmIksfNEGCqCDBhSgATrySP8BeURQhffogUDiocoCUqAeMsjnOnBQiFTMgwLnSKgLcnDBVwxCfwx1KAXMgU8Y0GOjIISGOFyQwH8WMKADxeY8SHrPfO4ToQJZxz33oc8jCsQU0JDiPqrAilVQ8YMg/EJXwpETCqShF7FIBz5r6k8K9ACZo5QHQqRp0JXmkxzHKIQVpKoOfCbQHtZ4hf6yulUKsAOfMqgHBdRRg324IA2M1J8KpTrFPCrVpRRYqUDIoVSaoqOc5hRIDBCxC0iCxRVr2McamCGTHEQjBjZgRy6K6YdcbFQMFECEPSIoD5K60IHYvIccXimLd+SgC/igADDsQAFCoOKCLlhGIfZhWtTAUsAXrN3DZnnRh33EwRj7uMEjVejCf0ZwshSoLAVEC05ZILey++isQRPIh1/AYZ0zuUZHhCCMZyyDJo64RjYSUQVjSMMYVKAAHcDxjFRIkwLEGMYKa9hBeMhCGsEIQinAoYuzcgEa0QhGD44YhHGYYb/9pYEWpCGNVLzxCsaIRjMEuMgMEtcgxqVAec+bXvvuI78bRu8+4mvQgRTCBYx0oGksWJDPMhCbsiDDPsogjfGw2LAWoSIFaIyMZ4whMAEBACH5BAEtAPwALAoAEwDxAMcBh/3+///89vz8/P/7+/j7//j6/Or68Pz5//r1//758f726fP4/uj57v705PHx8v3t7f3qyv3pyP3px+fv/uLo8P3nw/znwvzlvfzg4Pza2vzX1/vV1erV/fvS0vvOzvrGxvrDw/nBYvi2SPe2R/izs/iurvirq/akG/WiFvWhFPWgEPWeC/aZmfWNjfWLi/SCgtj14uDm7tnm/d/l7d7k7N3j69Tk/dzi69vh6tnf59je59fd5tbc5M/h/c/g/c3f/dXb5NTa49PZ4tHY4NHX4NDW38/V3svV4cnx2Mjw18fw1sXw1cLv07/u0LTrybTryMrd/avpwo3hrHXbmm3ZlWHWjF7Vis7U3c3U3czT3MvR2srQ2cnP2cfN1sbM1sXL1cTK1MPK08PJ0sLI0sHH0cTGyr7Fz73Dzbi+yLa9x7W8xrS7xbC2wdOo+6+1wKuyvamvuqivuqeuuaWrt6SrtqKptKGos6Cmsp+msZuirZqhrFPSgVLSgTvMcHao+W6j+JmgrJifq5edqZadqZWcqJKYpZCXo4+Woo6VoouSnomQnYmPnIiPm4eOm4SLmISLl4GIlWOb+H+Gk1+Z+E+P9zyC9juC9i/JaCjHYiXGYCLFXga21Lt7+ahV9/R8fPN3d/lzFvNxcfJiYvFhYfBVVfBLS+9ISO9GRu9ERHd+jHZ9i3V8inR7iXJ5h3F4hm92hGVse2NqeGJpeGFod15mdV5ldF9kbl1kc1xjclticVpicV1hbFlhcFlgb1deblRbalNaalJZaVFZaFBYZ1BXZ09WZk1UZExUY0tTY0tSYkpRYUlQYEhQYJo0EkdPX0ZOXkZNXUVMXERLXENLW0JKWkFJWUFIWUBHWD5GVj1FVThAUTg/UDc+TzY+TjU9TjQ8TTNBVTM7TDM6SzI5Sy01RiszRCgwQScvQSYuQCUtPyUsPiQrPSMrPSIqPCEpOyAoOh8nORsjNhsiNRoiNBggMxcfMhYeMRYeMBUdLxQcLxEZLBEYJwAAAAAAAAAAAAAAAAj/APkJHEiwoMGDCBMqXMiwocOHBadAnEixosWLA2Vg3MhxIIqOIK0oEVhlCciTKFOqXMmSJROCUVrKnEmzps2bOHPq3Mmzp8+fQINe5DMwptCjSFOegHDUpMAnSaNKnUpRysBLVLNq3cq1q9evYMOKHUu2rNmzaNOqXcu2rdu3cOPKnUu3rt27ePPq3cu3r9+/gAMLHky4sOHDiBMrXsy4sePHkCNLnky5suXLmDNr3sy5s+fPoEOLHk26tOnTqFOrXs26tevXsGPLnk27tu3buHPr3s27t+/fwIMLH068uPHjyJMrX868ufPn0KNLn069uvXr2LNr3869u/fv4MOL/x9Pvrz58+jTq1/Pvr379/Djy59Pv779+/jz69/Pv7///wAGKOCABBZo4IEIJqjgggw26OCDEEYo4YQUVmjhhRhmqOGGHHbo4YcghijiiCSWaOKJKKao4oostujiizDGKOOMNNZo44045qjjjjz26OOPQAYp5JBEFmnkkUgmqeSSTDbp5JNQRinllFRWaeWVWGap5ZZ5FeDll2CGWQCAYpb5JZlmlolmmmGuyeaZ/73ZZnxpFiQnmO/d6aVAeu7JXp+A4rleoISOqV6hhB6KaKDpLZroeY4+Wl6kko5HaaXiXWqme5rW+Wenan4K6pyKjirmoKaeWmqqcDbKqqCuvv/qZ6yyoiqrobS+amutu6ba3q2/8iqqqXmyCp+vdIJKX6f2XYpfpPotyl+hcepJoKdcZqvtttx26+234IYbXDPklmvuuc0A2Awo7Lbrrrvp/rfuu/SyG69/89b77r395atvu/zy5++/oATc3j4IJ5xwQQP/a3B6CkcssUAN6/uweRJnLHHF9V5MnsYgJ8wxvR6LF/LJI++r3skoEwwvxCyHnPLL58Xcssv21myzzDjnXN7OKKMrNLkYAw20e0YnffDJu5RRhgBO23I0ezs7kPQ+VFd9NdYra331ekBb/XXXNoutNNkxm2002F6fDfPWO7MNt81yz81y1naHvHTeIO/rzXfGSP89ceCCKwxf4QvHhzh9gtvHN3526wc3f2P3F/eAfYur+eacd+7556CHLvropJdu+umop6766qxD2ULrpXnwIAsOkiDQAxCWoGAotkvYgSiwBy/88MQXb/zxyCev/PLMN+/889BHL/301Fdv/fXYZ6/99tx37/334Icv/vjkl2/++einr/767Lfv/vvwxy///PTXb//9+Oev//789+///xfyxTSmgQ14LIgCFODHIVRxwARyowgNtEMsEqggBFJjDBTkDSxegZAxhIUCayAGAg8IDDeMUEFgyAYCM1i6MzgIDQMxQ2ECAgAh+QQBLQD6ACwPABMA7QDHAYf9/v///Pb8/Pz/+/v4+//4+vzq+vD8+f/69f/++fH+9unz+P7o+e7+9OTx8fL96cj96cfn7/7i6PD958P858L85b384OD82tr819f71dXq1f370ND6xsb6w8P5wWL4tkj3tkf4sbH4q6v2pBv1ohb1oRT1oBD1ngv2k5P1i4v0goLY9eLa5/3g5u7Z5v3f5e3e5Ozd4+vU5P3c4uvb4erZ3+fY3ufX3ebW3OTP4f3P4P3N3/3V2+TU2uPT2eLR2ODR1+DQ1t/P1d7L1eHJ8djI8NfH8NbF8NXC79O/7tC068m068jK3f2r6cKN4ax125pn2JFe1YrO1N3N1N3M09zL0drK0NnJz9nHzdbGzNbFy9XEytTDytPCyNLBx9HExsq+xc+7wcy4vsi2vce1vMa0u8WzucSwt8GwtsHTqPuvtcCrsr2pr7qnrrmlq7ekq7ajqrWiqbSgprKfprGdpLCcoq6boq2aoaxT0oE7zHB2qPluo/iZoKyYn6uXnamWnamVnKiSmKWQl6OPlqKOlaKLkp6JkJ2Jj5yIj5uHjpuFjJmEi5iEi5eBiJWAhpRhmvh/hpNXlPg8gvY7gvYvyWgox2IlxmAixV4GttT0fHzzd3e7e/nxYWHwVVWoVffwS0vvSEjvRkbvRER3fox2fYt1fIp0e4lyeYdxeYZxeIZvdoRlbHtiaXhhaHdfZ3VeZnVeZXRfZG5dZHNcY3JbYnFaYnFdYWxZYXBZYG9XXm5UW2pSWWlRWWhQWGdQV2dPVmZNVGRMVGNLU2NLUmJKUWFJUGBIUGBHT19GTl5GTV1FTFxES1xDS1tCSlpBSVlBSFlAR1g+RlY9RVU5QVI4QFE4P1A3Pk82Pk41PU4zQVUzO0wzOksyOUsxOUowOEktNUYrM0QpMEIoMEEnL0EmLkAlLT8lLD4kKz0jKz0iKjwhKTsgKDofJzkdJTccJDYbIzYbIjUaIjQYIDMXHzIWHjEWHjAVHS8UHC8RGSwRGCcAAAAAAAAAAAAAAAAAAAAAAAAI/wD1CRxIsKDBgwgTKlzIsKHDhxAjSpxIsSJBFhYzatzIkWCUjiBDdnwksqTJkyhTqlzJsqXLlzBjypxJs6bNmzDx4NzZkCRPiA9wQhn45KdRgpGOKl3KdKHPplCjSp1KtarVq1izat3KtavXr2DDih1LtqzZs2jTql3Ltq3bt3Djyp1Lt67du3jz6t3Lt6/fv4ADCx5MuLDhw4gTK17MuLHjx5AjS55MubLly5gza97MubPnz6BDix5NurTp06hTq17NurXr17Bjy55Nu7bt27hz697Nu7fv38CDCx9OvLjx48iTK1/OvLnz59CjS59Ovbr169iza9/Ovbv37+DDi/8fT768+fPo06tfz769+/fw48ufT7++/fv48+vfz7+///8ABijggAQWaOCBCCao4IIMNujggxBGKOGEFFZo4YUYZqjhhhx26OGHIIYo4ogklmjiiSimqOKKLLbo4oswxijjjDTWaOONOOao44489ujjj0AGKeSQRBZp5JFIJqnkkkw26eSTUEYp5ZRUVmnllVhmqeWWXHbp5ZdghinmmGSWaeaZaKap5ppstunmm3DGKeecdNZJWz545lPAnnz2uWd8eQbqZ5+ABprnoH/CZ6ihg8aHyaOYLKonofBBCumilL5n6aWC8unopo8ymqimoIbaKaClmornqO7hmeqpirr/Wqqghcq6Ka2x5gkqru8teuuhtQZqKa92Fmvsscgmq+yyzDbr7LPQRivttNRWa+212Gar7bbcduvtt+CGK+645JZrrpIpnIvWBgCi8F8IAikQILz6aUKvgBtwou6+/Pbr778AByzwwAQXbPDBCCes8MIMN+zwwxBHLPHEFFds8cUYZ6zxxhx37PHHIIcs8sgkl2zyySinrPLKLLfs8sswxyxzZ144gkPNOAj0DmxrRLPMM2bItPNCEghUdEHeJFJD0jXo7NDRAw0dkQRQC0QPM1gzohDUV2dt9ENUhy1VOFjoo0U3QjN0dNUCuaOPBG5H/XRBUmdU99ZyF8Q23i+x/5ERNWLoQ4Y4LgnxyzOwvEP1O68kIoUwzggjhT7vqPKMM1g8HrkUheDDjCKe2/C24mFXfjkWYECzzSL6/LALM8YEIYHiQWADRuqr62P4M7Swo08PtSDjDBkSFPP24lWHTTUaVB+PvPJi633Q3lCNYY829sDhEi1+SCCHPUXX04Y+twCiDyC16FPPHfr8wUv5EqBP+egDze78+hK4vwoaPpyjjyx9kEAgVjG7GChjDRLYX//0wT19fE8frSiDPq5wDQnc4HiUS17RqGYKWnABg7Nrngin1zyCUK8pzaCDBOrgCpeQYwYSeME8iiaPFujDHDPQxwzMoQ96xECH6cChDv95uDP7Ga2IVPOhBGaQjhsQIhXy0Ec5YiCBFuBgdqwQxNucCEWBwFCGEiAH1pjxDRtisGvM6MLbSsGMORSNCqtQhQjR2IUN1q+E0TOa8qTSjhZU0XctUQcMY0CPoilOH+fI4Q71UUMdiiORQ5yfEekXthouURzEIEQV4qEPdMDQaPWQBivelslN6kOQ+iBkJ2mgjxaoYW06S54e9QEDQ+RChKQDIULy+DarSIN5Z5hGSyTACztI4A71MGTRbuEHffjhFvqwRxzyBwtmOhOaRZSa/cImTWqyAwdbuIc+fGHMQZxidi04BiEk8M1w6qOY+kCmPnTRB328YRgSEN3RDlmXPz3yoRduAGEuRbg3XvayKmFoRjOYEQaXYMEZzkAF6Q5JhWE4YxhToBwsnPELIFT0ohnNZv1It7iNdpQU3MCFILXAjGb8ggchBAI4yIBSlc7goc5Ihe+sMIxmJCMLEjDGQfn5teMRwo/OC+EeS2jCgk7mbtMzYd2g2hCC6gMWDR2DM5RDVemNlCBdJdoexeCMYiwDDHUJCAA7\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {}
    }
   ],
   "source": [
    "example_run = run_episode(valid_scenarios[0], mlp_action_model, render=True)\n",
    "print(\"success:\", example_run[\"success\"])\n",
    "print(\"steps:\", example_run[\"steps\"])\n",
    "print(\"invalid pickup/dropoff:\", example_run[\"invalid_pickup_or_dropoff\"])\n",
    "print(\"actions:\", [ACTION_NAMES[a] for a in example_run[\"actions\"]])\n",
    "print(\"initial frame:\")\n",
    "print(example_run[\"frames\"][0])\n",
    "print(\"final frame:\")\n",
    "print(example_run[\"frames\"][-1])\n",
    "\n",
    "print(\"animated rollout:\")\n",
    "show_episode_gif(valid_scenarios[0], example_run[\"actions\"], path=\"model_rollout.gif\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fe5ae71",
   "metadata": {
    "id": "0fe5ae71"
   },
   "source": [
    "### 8.6 Generate Submission Files\n",
    "\n",
    "The test set contains scenarios without expert actions. A prediction is a list of actions for each scenario.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36fb909e",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000,
     "referenced_widgets": [
      "0162387cc7fd46839d2545d81780f346",
      "1093831c900b4d01994ffc5d84e2834c",
      "2b40f2d3139347d188392751bebe3b0e",
      "5285a15fbf7c4de8bcd50395ae8baf62",
      "6b9420768d6e48b89539253121c2895c",
      "9f9560ee2f0b40c3ae864f8dfeef760a",
      "4997a9b601094b779cc4a0bcc9e03faf",
      "6371153f7c0a477b9b6a08e60cad48ae",
      "5dd242c01fe848c8a822e93113fde5d7",
      "672c38d036e946b089cd5325ee811936",
      "39a9470fce5e43cd8d888cc4c7e6e94b"
     ]
    },
    "id": "36fb909e",
    "outputId": "cf67b943-f402-43ef-86f8-997d2c12ef14"
   },
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "Generating predictions:   0%|          | 0/5 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "0162387cc7fd46839d2545d81780f346"
      }
     },
     "metadata": {}
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "{'layout_id': 'test_0000',\n",
       " 'episode_seed': 300000,\n",
       " 'actions': [2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2,\n",
       "  2]}"
      ]
     },
     "metadata": {},
     "execution_count": 13
    }
   ],
   "source": [
    "def generate_predictions(scenarios, action_fn, limit=None):\n",
    "    \"\"\"Generate action sequences for scenarios.\"\"\"\n",
    "    predictions = []\n",
    "    for scenario in tqdm(scenarios[:limit], desc=\"Generating predictions\"):\n",
    "        episode = run_episode(scenario, action_fn)\n",
    "        predictions.append({\n",
    "            \"layout_id\": scenario[\"layout_id\"],\n",
    "            \"episode_seed\": scenario[\"episode_seed\"],\n",
    "            \"actions\": episode[\"actions\"],\n",
    "        })\n",
    "    return predictions\n",
    "\n",
    "\n",
    "def save_predictions_zip(predictions, path=\"predictions.zip\"):\n",
    "    \"\"\"Write predictions.jsonl into a zip file.\"\"\"\n",
    "    jsonl_path = Path(\"predictions.jsonl\")\n",
    "    with jsonl_path.open(\"w\", encoding=\"utf-8\") as f:\n",
    "        for pred in predictions:\n",
    "            f.write(json.dumps(pred) + \"\\n\")\n",
    "    with zipfile.ZipFile(path, \"w\") as zf:\n",
    "        zf.write(jsonl_path, \"predictions.jsonl\")\n",
    "    print(f\"Saved {path}\")\n",
    "\n",
    "\n",
    "# For a real submission, use limit=None.\n",
    "test_predictions_preview = generate_predictions(test_scenarios, mlp_action_model, limit=5)\n",
    "test_predictions_preview[0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fffd1365",
   "metadata": {
    "id": "fffd1365"
   },
   "outputs": [],
   "source": [
    "# Uncomment these lines to generate a full submission file.\n",
    "# test_predictions = generate_predictions(test_scenarios, mlp_action_model, limit=None)\n",
    "# save_predictions_zip(test_predictions, \"predictions.zip\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c0fcb42",
   "metadata": {
    "id": "8c0fcb42"
   },
   "source": [
    "## 9. Hints for Improvement\n",
    "\n",
    "Here are some questions worth thinking about after you run the baseline.\n",
    "\n",
    "### Representation\n",
    "\n",
    "- Does the input format make the important geometry easy for the model to see?\n",
    "- Are all parts of the observation equally useful, or should some parts be encoded differently?\n",
    "- Does flattening the grid lose information that a model could otherwise use?\n",
    "\n",
    "### Model\n",
    "\n",
    "- Is the baseline model a good match for this kind of structured input?\n",
    "- Should the model process the map and the numerical features in the same way?\n",
    "- Can the model learn both local decisions and longer-range navigation patterns?\n",
    "\n",
    "### Failure Analysis\n",
    "\n",
    "- Does high action accuracy lead to high complete-episode success?\n",
    "- Which episodes fail most often: before pickup, after pickup, near walls, or near the destination?\n",
    "- Are there rare actions or rare situations that the model does not learn well?\n",
    "- When you replay failed episodes, do the mistakes look random, systematic, or caused by earlier drift?\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "babyai",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.20"
  },
  "colab": {
   "provenance": [],
   "include_colab_link": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}