{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Library Imports"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "0OFWJji-GcUt"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import gym\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torch.nn.functional as F\n",
        "import time\n",
        "import math\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "from IPython.display import clear_output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "LeifZqBYOXbx"
      },
      "outputs": [],
      "source": [
        "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
        "dtype = torch.float"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "PcGuCbIzGg7w"
      },
      "outputs": [],
      "source": [
        "class CsvLogger:\n",
        "    \"\"\"\n",
        "    A quick-and-simple CSV logger that appends\n",
        "    rows to a specified file on disk.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, file_name):\n",
        "        self.file_name = file_name\n",
        "\n",
        "        with open(f\"{self.file_name}.csv\", \"w\") as f:\n",
        "            # Create/empty the file initially\n",
        "            pass\n",
        "\n",
        "    def write_entry(self, text_line):\n",
        "        with open(f\"{self.file_name}.csv\", \"a\") as f:\n",
        "            f.write(f\"{text_line}\\n\")\n",
        "\n",
        "\n",
        "##############################################\n",
        "# Environment Runner\n",
        "##############################################\n",
        "class EnvironmentRunner:\n",
        "    \"\"\"\n",
        "    Manages interactions with an OpenAI Gym environment:\n",
        "    - Resets the environment\n",
        "    - Steps through it given an agent's actions\n",
        "    - Logs returns and gathers trajectory data\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, gym_env):\n",
        "        self.gym_env = gym_env\n",
        "        self.num_actions = self.gym_env.action_space.n\n",
        "\n",
        "        self.logger = CsvLogger(\"episode_returns\")\n",
        "        self.logger.write_entry(\"training_step,return\")\n",
        "\n",
        "        self.observation = self.gym_env.reset()\n",
        "        self.episodes_count = 0\n",
        "\n",
        "\n",
        "    def run(self, agent, show_render=False):\n",
        "            \"\"\"\n",
        "            Runs one full episode:\n",
        "            1) Resets environment\n",
        "            2) Steps until done\n",
        "            3) Logs returns\n",
        "            4) Returns the collected trajectory\n",
        "            \"\"\"\n",
        "            obs_list = []\n",
        "            actions_list = []\n",
        "            rewards_list = []\n",
        "            done_list = []\n",
        "            policy_list = []\n",
        "            values_list = []\n",
        "\n",
        "            # initial reset\n",
        "            self.observation = self.gym_env.reset()\n",
        "            obs_list.append(torch.tensor(self.observation))\n",
        "\n",
        "            finished = False\n",
        "            while not finished:\n",
        "                # Let agent infer the next action\n",
        "                chosen_action, distribution, val_est = agent.inference(\n",
        "                    torch.tensor(self.observation, dtype=dtype, device=device)\n",
        "                )\n",
        "\n",
        "                next_obs, reward, finished, info = self.gym_env.step(chosen_action)\n",
        "\n",
        "                # Store\n",
        "                obs_list.append(torch.tensor(next_obs))\n",
        "                actions_list.append(chosen_action)\n",
        "                policy_list.append(torch.tensor(distribution))\n",
        "                values_list.append(val_est)\n",
        "                rewards_list.append(torch.tensor(reward))\n",
        "                done_list.append(finished)\n",
        "\n",
        "                # Check if episode ended\n",
        "                if finished:\n",
        "                    if \"return\" in info:\n",
        "                        # Log it\n",
        "                        self.logger.write_entry(f\"{self.episodes_count},{info['return']}\")\n",
        "\n",
        "                # Optional render\n",
        "                if show_render:\n",
        "                    self.gym_env.render()\n",
        "                    time.sleep(0.024)\n",
        "\n",
        "                self.observation = next_obs\n",
        "\n",
        "            self.episodes_count += 1\n",
        "            return self.build_trajectory(obs_list, actions_list, rewards_list, done_list, policy_list, values_list)\n",
        "\n",
        "    @staticmethod\n",
        "    def build_trajectory(obs, acts, rews, finished_flags, pols, vals):\n",
        "        return {\n",
        "            \"obs\": obs,\n",
        "            \"actions\": acts,\n",
        "            \"rewards\": rews,\n",
        "            \"dones\": finished_flags,\n",
        "            \"pis\": pols,\n",
        "            \"vs\": vals,\n",
        "            \"length\": len(obs)\n",
        "        }\n",
        "        \n",
        "class LoggingEnvRunner(EnvironmentRunner):\n",
        "    \"\"\"\n",
        "    Extends EnvironmentRunner to log episode returns.\n",
        "    \"\"\"\n",
        "    def __init__(self, env):\n",
        "        super().__init__(env)\n",
        "        self.episode_returns = []\n",
        "\n",
        "    def run(self, agent):\n",
        "        trajectory = super().run(agent)  # normal run\n",
        "        # Summation of the episode's rewards:\n",
        "        ep_return = float(np.sum(trajectory[\"rewards\"]))\n",
        "        self.episode_returns.append(ep_return)\n",
        "        return trajectory"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "rJBube37GhXH"
      },
      "outputs": [],
      "source": [
        "##############################################\n",
        "# A simple Gym Wrapper\n",
        "##############################################\n",
        "class GymWrapper(gym.Wrapper):\n",
        "    \"\"\"\n",
        "    A wrapper that folds multiple historical observations\n",
        "    into a single stacked observation.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, env, history_len):\n",
        "        super().__init__(env)\n",
        "        self.history_len = history_len\n",
        "        self.obs_dim = env.observation_space.shape[0]\n",
        "        self.num_actions = env.action_space.n\n",
        "\n",
        "    def reset(self):\n",
        "        self.episode_return = 0\n",
        "        self.observations_rollout = []\n",
        "\n",
        "        obs = self.env.reset()\n",
        "        self.observations_rollout.append(obs)\n",
        "\n",
        "        return self.aggregate()\n",
        "\n",
        "    def aggregate(self):\n",
        "        \"\"\"\n",
        "        Stacks the last N observations (with possible zero-padding).\n",
        "        Returns them as a flattened array of shape (1, -1).\n",
        "        \"\"\"\n",
        "        stacked = np.zeros((self.history_len, self.obs_dim))\n",
        "\n",
        "        current_length = len(self.observations_rollout)\n",
        "        if current_length == self.history_len:\n",
        "            stacked = np.array(self.observations_rollout)\n",
        "        else:\n",
        "            stacked[self.history_len - current_length :] = np.array(\n",
        "                self.observations_rollout\n",
        "            )\n",
        "\n",
        "        return stacked.flatten().reshape(1, -1)\n",
        "\n",
        "    def step(self, action):\n",
        "        next_obs, reward, done, info = self.env.step(action)\n",
        "        self.update_history(next_obs)\n",
        "        aggregated_obs = self.aggregate()\n",
        "\n",
        "        self.episode_return += reward\n",
        "        if done:\n",
        "            info[\"return\"] = self.episode_return\n",
        "\n",
        "        return aggregated_obs, reward, done, info\n",
        "\n",
        "    def update_history(self, new_obs):\n",
        "        if len(self.observations_rollout) == self.history_len:\n",
        "            # drop oldest\n",
        "            self.observations_rollout = self.observations_rollout[1:]\n",
        "        self.observations_rollout.append(new_obs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [],
      "source": [
        "##############################################\n",
        "# Buffer Replay (Experience)\n",
        "##############################################\n",
        "class BufferReplay:\n",
        "    \"\"\"\n",
        "    Stores entire episodes (trajectories), then allows sampling\n",
        "    sub-portions for training (k-step unroll & n-step return).\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, capacity, num_actions):\n",
        "        self.capacity = capacity\n",
        "        self.memory = []\n",
        "        self.position = 0\n",
        "        self.num_actions = num_actions\n",
        "\n",
        "    def add_trajectories(self, new_trajectories):\n",
        "        \"\"\"\n",
        "        Insert new trajectories (episodes) into the memory buffer.\n",
        "        Overwrites older ones if the capacity is reached.\n",
        "        \"\"\"\n",
        "        for traj in new_trajectories:\n",
        "            if len(self.memory) < self.capacity:\n",
        "                self.memory.append(None)\n",
        "            self.memory[self.position] = traj\n",
        "            self.position = (self.position + 1) % self.capacity\n",
        "\n",
        "    def sample_sub_trajectory(self, k, n, discount):\n",
        "        \"\"\"\n",
        "        Randomly picks a single stored trajectory, picks a start index,\n",
        "        returns the k-step unroll data plus n-step returns.\n",
        "        \"\"\"\n",
        "        data = {\n",
        "            \"obs\": None,\n",
        "            \"pi\": [],\n",
        "            \"v\": [],\n",
        "            \"actions\": [],\n",
        "            \"rewards\": [],\n",
        "            \"return\": [],\n",
        "        }\n",
        "\n",
        "        # Choose a random trajectory\n",
        "        mem_idx = np.random.choice(len(self.memory), 1)[0]\n",
        "        chosen_length = self.memory[mem_idx][\"length\"]\n",
        "        last_idx = chosen_length - 1\n",
        "\n",
        "        # Random start\n",
        "        start = np.random.choice(chosen_length, 1)[0]\n",
        "\n",
        "        # We'll record the initial observation\n",
        "        data[\"obs\"] = self.memory[mem_idx][\"obs\"][start]\n",
        "\n",
        "        # Collect data for each unroll step\n",
        "        for step in range(start, start + k + 1):\n",
        "            lookahead = step + n\n",
        "\n",
        "            # If looking beyond trajectory end, v_n = 0\n",
        "            if lookahead >= last_idx:\n",
        "                future_value = torch.tensor(\n",
        "                    [0.0], device=device, dtype=dtype\n",
        "                )\n",
        "            else:\n",
        "                future_value = self.memory[mem_idx][\"vs\"][lookahead] * (discount**n)\n",
        "\n",
        "            # sum of discounted rewards up to n or end\n",
        "            total_val = future_value.clone()\n",
        "            max_reward_idx = min(last_idx, lookahead)\n",
        "            enumer_rewards = list(\n",
        "                enumerate(self.memory[mem_idx][\"rewards\"][step:max_reward_idx])\n",
        "            )\n",
        "            for i, single_r in enumer_rewards:\n",
        "                total_val += single_r * (discount**i)\n",
        "\n",
        "            data[\"return\"].append(total_val)\n",
        "\n",
        "            # Not storing reward for the very initial step in the unroll\n",
        "            if step != start:\n",
        "                if 0 < step <= last_idx:\n",
        "                    data[\"rewards\"].append(self.memory[mem_idx][\"rewards\"][step - 1])\n",
        "                else:\n",
        "                    data[\"rewards\"].append(torch.tensor([0.0], device=device))\n",
        "\n",
        "            # Pi distribution\n",
        "            if 0 <= step < last_idx:\n",
        "                data[\"pi\"].append(self.memory[mem_idx][\"pis\"][step])\n",
        "            else:\n",
        "                # In case we are beyond the real trajectory\n",
        "                uniform_probs = np.ones(self.num_actions) / self.num_actions\n",
        "                data[\"pi\"].append(torch.tensor(uniform_probs, dtype=dtype))\n",
        "\n",
        "        # Build the real set of actions from the actual trajectory\n",
        "        max_valid_step = min(last_idx - 1, start + k - 1)\n",
        "        num_steps_valid = max_valid_step - start\n",
        "        data[\"actions\"] = self.memory[mem_idx][\"actions\"][\n",
        "            start : start + num_steps_valid + 1\n",
        "        ]\n",
        "\n",
        "        # Fill with random actions if we unroll beyond the stored trajectory\n",
        "        fill_count = k - num_steps_valid + 1\n",
        "        for _ in range(fill_count):\n",
        "            rand_act = np.random.choice(self.num_actions, 1)[0]\n",
        "            data[\"actions\"].append(rand_act)\n",
        "\n",
        "        return data\n",
        "\n",
        "    def sample_batch(self, batch_size, k, n, discount=0.99):\n",
        "        \"\"\"\n",
        "        Returns a batch (list) of sub trajectories. Each item\n",
        "        in the batch has the keys: obs, pi, v, actions, rewards, return\n",
        "        \"\"\"\n",
        "        batch_data = []\n",
        "        for _ in range(batch_size):\n",
        "            sample = self.sample_sub_trajectory(k, n, discount)\n",
        "            batch_data.append(sample)\n",
        "        return batch_data\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.memory)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "dTamqwyJGhik"
      },
      "outputs": [],
      "source": [
        "##############################################\n",
        "# Representation, Dynamics, Prediction models\n",
        "##############################################\n",
        "class RepresentationNet(nn.Module):\n",
        "    \"\"\"\n",
        "    Maps an environment observation into a hidden state.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, input_dim, hidden_dim):\n",
        "        super().__init__()\n",
        "        self.input_dim = input_dim\n",
        "        self.hidden_dim = hidden_dim\n",
        "\n",
        "        layers = [\n",
        "            nn.Linear(self.input_dim, 50),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(50, 50),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(50, 50),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(50, 50),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(50, self.hidden_dim),\n",
        "        ]\n",
        "        self.model = nn.Sequential(*layers)\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.model(x)\n",
        "\n",
        "\n",
        "class DynamicsNet(nn.Module):\n",
        "    \"\"\"\n",
        "    Predicts the next hidden state and immediate reward\n",
        "    from current hidden state and action encoding.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, hidden_dim, action_space):\n",
        "        super().__init__()\n",
        "        self.hidden_dim = hidden_dim\n",
        "        self.num_actions = action_space\n",
        "\n",
        "        net_layers = [\n",
        "            nn.Linear(self.hidden_dim + 1, 50),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(50, 50),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(50, 50),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(50, 50),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(50, self.hidden_dim + 1),  # last dimension is reward\n",
        "        ]\n",
        "        self.model = nn.Sequential(*net_layers)\n",
        "\n",
        "    def forward(self, x):\n",
        "        out = self.model(x)\n",
        "        next_state, reward_est = out[:, : self.hidden_dim], out[:, -1]\n",
        "        return next_state, reward_est\n",
        "\n",
        "\n",
        "class PredictionNet(nn.Module):\n",
        "    \"\"\"\n",
        "    Given a hidden state, outputs:\n",
        "      - A policy distribution (num_actions)\n",
        "      - A scalar value estimate\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, hidden_dim, num_actions):\n",
        "        super().__init__()\n",
        "        self.hidden_dim = hidden_dim\n",
        "        self.num_actions = num_actions\n",
        "\n",
        "        net_blocks = [\n",
        "            nn.Linear(self.hidden_dim, 50),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(50, 50),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(50, 50),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(50, self.num_actions + 1),  # final: [policy_logits, value]\n",
        "        ]\n",
        "        self.model = nn.Sequential(*net_blocks)\n",
        "\n",
        "    def forward(self, hidden_x):\n",
        "        raw_output = self.model(hidden_x)\n",
        "        raw_policy = raw_output[:, : self.num_actions]\n",
        "        raw_value = raw_output[:, -1]\n",
        "\n",
        "        # Softmax for policy\n",
        "        policy = F.softmax(raw_policy, dim=1)\n",
        "        return policy, raw_value\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "iv8r4gPrGiBl"
      },
      "outputs": [],
      "source": [
        "##############################################\n",
        "# MCTS Support Classes\n",
        "##############################################\n",
        "class AdaptiveNormalizer:\n",
        "    \"\"\"\n",
        "    Simple min-max normalizer that tracks running min/max\n",
        "    so we can scale Q-values in MCTS.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self):\n",
        "        self.max_val = float(\"-inf\")\n",
        "        self.min_val = float(\"inf\")\n",
        "\n",
        "    def update(self, val):\n",
        "        val_cpu = val.cpu()\n",
        "        self.max_val = max(self.max_val, val_cpu)\n",
        "        self.min_val = min(self.min_val, val_cpu)\n",
        "\n",
        "    def normalize(self, val):\n",
        "        val_cpu = val.cpu()\n",
        "        if self.max_val > self.min_val:\n",
        "            return ((val_cpu - self.min_val) / (self.max_val - self.min_val)).to(\n",
        "                device\n",
        "            )\n",
        "        return val_cpu\n",
        "    \n",
        "    \n",
        "class TreeNode:\n",
        "    \"\"\"\n",
        "    Node for MCTS: stores children edges, prior,\n",
        "    aggregated value stats, and so on.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, prior_prob):\n",
        "        self.prior_prob = prior_prob\n",
        "        self.state_rep = None\n",
        "        self.reward_est = None\n",
        "        self.edges = {}  # action -> TreeNode\n",
        "\n",
        "        self.total_value_sum = 0.0\n",
        "        self.visit_count = 0\n",
        "\n",
        "    def is_expanded(self):\n",
        "        return len(self.edges) > 0\n",
        "\n",
        "    def avg_value(self):\n",
        "        if self.visit_count == 0:\n",
        "            return 0.0\n",
        "        return self.total_value_sum / self.visit_count\n",
        "    \n",
        "    \n",
        "    \n",
        "##############################################\n",
        "# Some utility function\n",
        "##############################################\n",
        "def minmax_normalize_state(s):\n",
        "    \"\"\"\n",
        "    Simple bounding of the input tensor to [0,1] range per row.\n",
        "    Not guaranteed to be safe for all tasks, but included for example.\n",
        "    \"\"\"\n",
        "    b_size = s.shape[0]\n",
        "    s_min = torch.min(s, dim=1)[0].reshape(b_size, 1)\n",
        "    s_max = torch.max(s, dim=1)[0].reshape(b_size, 1)\n",
        "    return (s - s_min) / (s_max - s_min)\n",
        "\n",
        "\n",
        "\n",
        "class MCTS:\n",
        "    \"\"\"\n",
        "    Runs MCTS simulations to select actions.\n",
        "    Has:\n",
        "      - root exploration noise\n",
        "      - expansions\n",
        "      - backup of value\n",
        "      - UCB calculation\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(\n",
        "        self,\n",
        "        num_actions,\n",
        "        dyn_net,\n",
        "        pred_net,\n",
        "        controlling_agent,\n",
        "        gamma=0.99,\n",
        "    ):\n",
        "        self.num_actions = num_actions\n",
        "        self.c1 = 1.25\n",
        "        self.c2 = 19652\n",
        "        self.gamma = gamma\n",
        "\n",
        "        self.root_dirichlet_alpha = 0.25\n",
        "        self.root_exploration_fraction = 0.25\n",
        "\n",
        "        self.dyn_net = dyn_net\n",
        "        self.pred_model = pred_net\n",
        "        self.agent = controlling_agent\n",
        "        self.value_tracker = None  # Assigned new for each search\n",
        "\n",
        "    def run(self, sims_count, root_state):\n",
        "        # Create the root\n",
        "        init_policy, init_value = self.pred_model(root_state)\n",
        "        init_policy, init_val = init_policy.detach(), init_value.detach()\n",
        "        self.root_node = self._initialize_root(root_state, init_policy)\n",
        "\n",
        "        # track min/max for value normalization\n",
        "        self.value_tracker = AdaptiveNormalizer()\n",
        "\n",
        "        # Perform MCTS simulations\n",
        "        for _ in range(sims_count):\n",
        "            self.search_path = []\n",
        "            self.search_path.append(self.root_node)\n",
        "            self.action_path = []\n",
        "\n",
        "            current_node = self.root_node\n",
        "            while current_node.is_expanded():\n",
        "                act_chosen, next_node = self._select_ucb_action(current_node)\n",
        "                self.search_path.append(next_node)\n",
        "                self.action_path.append(act_chosen)\n",
        "                current_node = next_node\n",
        "\n",
        "            # Expand the newly reached leaf\n",
        "            leaf_parent = self.search_path[-2]\n",
        "            new_value = self._expand_node(\n",
        "                leaf_parent, current_node, self.action_path[-1]\n",
        "            )\n",
        "\n",
        "            # Backup\n",
        "            self._backpropagate(new_value)\n",
        "\n",
        "        # Return (visit distribution, root value)\n",
        "        visit_counts = self._compute_pi()\n",
        "        return visit_counts, self.root_node.avg_value()\n",
        "\n",
        "    def _expand_node(self, parent_node, new_node, chosen_action):\n",
        "        next_s, new_pi, new_v, new_reward = self.agent.rollout_step(\n",
        "            parent_node.state_rep, [chosen_action]\n",
        "        )\n",
        "        next_s = next_s.detach()\n",
        "        new_pi = new_pi.detach()\n",
        "        new_v = new_v.detach()\n",
        "        new_reward = new_reward.detach()\n",
        "\n",
        "        new_node.state_rep = next_s\n",
        "        new_node.reward_est = new_reward\n",
        "\n",
        "        # create children edges\n",
        "        for a in range(self.num_actions):\n",
        "            new_node.edges[a] = TreeNode(new_pi[0, a])\n",
        "\n",
        "        return new_v\n",
        "\n",
        "    def _backpropagate(self, leaf_value):\n",
        "        \"\"\"\n",
        "        Moves up the search path, updating each node's total_value_sum and visits\n",
        "        with the discounted sum of rewards + leaf_value.\n",
        "        \"\"\"\n",
        "        for node in reversed(self.search_path):\n",
        "            node.total_value_sum += leaf_value\n",
        "            node.visit_count += 1\n",
        "\n",
        "            # Update normalizer with (reward + gamma * node_value)\n",
        "            self.value_tracker.update(node.reward_est + self.gamma * node.avg_value())\n",
        "\n",
        "            leaf_value = node.reward_est + self.gamma * leaf_value\n",
        "\n",
        "    def _select_ucb_action(self, node):\n",
        "        # Evaluate UCB for each child\n",
        "        ucb_scores = [\n",
        "            self._calc_ucb(node, node.edges[a]) for a in range(self.num_actions)\n",
        "        ]\n",
        "        best_act = np.argmax(ucb_scores)\n",
        "        return best_act, node.edges[best_act]\n",
        "\n",
        "    def _calc_ucb(self, parent, child):\n",
        "        # PUCT formula\n",
        "        pb_c = math.log((parent.visit_count + self.c2 + 1.0) / self.c2) + self.c1\n",
        "        pb_c *= math.sqrt(parent.visit_count) / (child.visit_count + 1.0)\n",
        "\n",
        "        prior_val = pb_c * child.prior_prob\n",
        "\n",
        "        if child.visit_count > 0:\n",
        "            val_score = self.value_tracker.normalize(\n",
        "                child.reward_est + self.gamma * child.avg_value()\n",
        "            )\n",
        "        else:\n",
        "            val_score = 0.0\n",
        "        return (prior_val + val_score).item()\n",
        "\n",
        "    def _compute_pi(self):\n",
        "        # For each possible action from root, gather visits\n",
        "        visits = []\n",
        "        for a in range(self.num_actions):\n",
        "            visits.append(self.root_node.edges[a].visit_count)\n",
        "        return np.array(visits)\n",
        "\n",
        "    def _add_root_noise(self, root):\n",
        "        noise = np.random.dirichlet([self.root_dirichlet_alpha] * self.num_actions)\n",
        "        frac = self.root_exploration_fraction\n",
        "        for act_id, n_val in zip(range(self.num_actions), noise):\n",
        "            root.edges[act_id].prior_prob = (\n",
        "                root.edges[act_id].prior_prob * (1 - frac) + n_val * frac\n",
        "            )\n",
        "        return root\n",
        "\n",
        "    def _initialize_root(self, root_tensor, p_init):\n",
        "        p_init = p_init.detach().cpu().numpy()\n",
        "        node = TreeNode(0)\n",
        "        node.state_rep = root_tensor\n",
        "        node.reward_est = 0\n",
        "\n",
        "        for i in range(self.num_actions):\n",
        "            node.edges[i] = TreeNode(p_init[0, i])\n",
        "\n",
        "        # Add exploration noise\n",
        "        node = self._add_root_noise(node)\n",
        "        return node\n",
        "    \n",
        "    \n",
        "def naive_depth_search(agent, state, num_actions, gamma_val, search_depth=3):\n",
        "    \"\"\"\n",
        "    Very naive search that fully expands all actions up to a given depth,\n",
        "    tracks predicted reward + discounted value at the leaf, picks best.\n",
        "    \"\"\"\n",
        "    possible_acts = np.arange(num_actions)\n",
        "    \n",
        "    # Just get the root value\n",
        "    _, root_v = agent.pred_net(state)\n",
        "    root_value = None\n",
        "\n",
        "    combined_rewards = torch.tensor([0.0], device=device)\n",
        "    \n",
        "    for depth in range(search_depth):\n",
        "        state = torch.repeat_interleave(state, num_actions, dim=0)\n",
        "        repeated_acts = np.repeat([possible_acts], num_actions**depth, axis=0).flatten()\n",
        "        \n",
        "        # Roll out one step\n",
        "        next_s, _, leaf_val, leaf_r = agent.rollout_step(state, repeated_acts)\n",
        "        state = next_s.detach()\n",
        "        leaf_val = leaf_val.detach()\n",
        "        leaf_r = leaf_r.detach()\n",
        "\n",
        "        # Expand reward sum\n",
        "        combined_rewards = torch.repeat_interleave(combined_rewards, num_actions, dim=0)\n",
        "        adjusted_r = leaf_r * (gamma_val**depth)\n",
        "        combined_rewards += adjusted_r\n",
        "\n",
        "    # discount leaf value\n",
        "    final_vals = leaf_val.cpu().numpy() * (gamma_val**search_depth)\n",
        "    # total\n",
        "    final_vals += combined_rewards.cpu().numpy()\n",
        "\n",
        "    # pick best\n",
        "    best_index = np.argmax(final_vals)\n",
        "    possible_branches = num_actions ** (search_depth - 1)\n",
        "    chosen_act = int(best_index / possible_branches)\n",
        "\n",
        "    return chosen_act, root_v\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [],
      "source": [
        "##############################################\n",
        "# Agent\n",
        "##############################################\n",
        "class Agent(nn.Module):\n",
        "    \"\"\"\n",
        "    Agent with optional MCTS or naive search to pick actions.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(\n",
        "        self,\n",
        "        sim_count,\n",
        "        num_actions,\n",
        "        rep_net,\n",
        "        dyn_net,\n",
        "        pred_net,\n",
        "        search_type=\"mcts\",\n",
        "        disc_factor=0.99,\n",
        "        naive_len=3,\n",
        "        epsilon=0.1,\n",
        "    ):\n",
        "        super().__init__()\n",
        "        self.rep_net = rep_net\n",
        "        self.dyn_net = dyn_net\n",
        "        self.pred_net = pred_net\n",
        "\n",
        "        self.num_actions = num_actions\n",
        "        self.gamma = disc_factor\n",
        "        self.search_type = search_type\n",
        "        self.simulations = sim_count\n",
        "        self.naive_search_depth = naive_len\n",
        "        self.temperature = 1.0\n",
        "        self.epsilon = epsilon\n",
        "\n",
        "        if self.search_type == \"mcts\":\n",
        "            self.mcts = MCTS(\n",
        "                num_actions, dyn_net, pred_net, self, gamma=disc_factor\n",
        "            )\n",
        "        else:\n",
        "            self.mcts = None\n",
        "\n",
        "    def forward(self, obs):\n",
        "        pass\n",
        "\n",
        "    def inference(self, obs_tensor):\n",
        "        \"\"\"\n",
        "        Returns:\n",
        "          (action_int, policy_distribution, estimated_value)\n",
        "        \"\"\"\n",
        "        # convert observation to hidden\n",
        "        hidden = self.rep_net(obs_tensor)\n",
        "\n",
        "        if self.mcts:\n",
        "            # MCTS-based\n",
        "            child_visits, root_val = self.mcts.run(self.simulations, hidden)\n",
        "            action_probs = child_visits / np.sum(child_visits)\n",
        "\n",
        "            # Apply temperature\n",
        "            adjusted_pi = (child_visits ** (1 / self.temperature)) / np.sum(\n",
        "                child_visits ** (1 / self.temperature)\n",
        "            )\n",
        "            action = np.random.choice(self.num_actions, p=adjusted_pi)\n",
        "            return action, action_probs, root_val\n",
        "        elif self.search_type == \"naive\":\n",
        "            # naive search\n",
        "            best_a, r_val = naive_depth_search(\n",
        "                self, hidden, self.num_actions, self.gamma, self.naive_search_depth\n",
        "            )\n",
        "            \n",
        "            greedy = torch.rand(1)\n",
        "\n",
        "            if greedy < self.epsilon:\n",
        "                # Explore: choose a random action\n",
        "                action = np.random.choice(self.num_actions)\n",
        "            else:\n",
        "                # Exploit: choose the best action\n",
        "                action = best_a\n",
        "            result_pi = np.zeros(self.num_actions, dtype=np.float32)\n",
        "            result_pi[action] = 1.0\n",
        "            return action, result_pi, r_val\n",
        "        else:\n",
        "            # direct prediction\n",
        "            with torch.no_grad():\n",
        "                pol, val = self.pred_net(hidden)\n",
        "            # sample from pol^1/T or argmax\n",
        "            pol_np = pol[0].cpu().numpy()\n",
        "            pol_np = pol_np ** (1.0 / self.temperature)\n",
        "            pol_np = pol_np / pol_np.sum()\n",
        "            action = np.random.choice(self.num_actions, p=pol_np)\n",
        "            return action, pol_np, val\n",
        "\n",
        "    def initial_step(self, obs):\n",
        "        \"\"\"\n",
        "        The initial representation + prediction for the root.\n",
        "        \"\"\"\n",
        "        s = self.rep_net(obs)\n",
        "        pol, v = self.pred_net(s)\n",
        "        return s, pol, v\n",
        "\n",
        "    def rollout_step(self, hidden_s, chosen_actions):\n",
        "        \"\"\"\n",
        "        Takes in hidden states and actions, uses the dynamics net\n",
        "        to get next hidden states + rewards, then the prediction net\n",
        "        for policy + value.\n",
        "        \"\"\"\n",
        "        batch_sz = hidden_s.shape[0]\n",
        "        # Normalize action to [0,1]\n",
        "        act_enc = torch.tensor(\n",
        "            chosen_actions, dtype=dtype, device=device\n",
        "        ).reshape(batch_sz, 1)\n",
        "        act_enc /= self.num_actions\n",
        "\n",
        "        # feed dynamics\n",
        "        dyn_input = torch.cat([hidden_s, act_enc], dim=1)\n",
        "        next_hidden, predicted_reward = self.dyn_net(dyn_input)\n",
        "\n",
        "        # get next policy + value\n",
        "        p, v = self.pred_net(next_hidden)\n",
        "\n",
        "        return next_hidden, p, v, predicted_reward\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 576
        },
        "id": "j4um4-S5r17Z",
        "outputId": "17e692a3-7ce6-4cb3-8195-8eb50ae823a6"
      },
      "outputs": [],
      "source": [
        "def train_with_search_policy(search_type):\n",
        "    \"\"\"\n",
        "    Trains a MuZero_Agent with the given `search_type` using\n",
        "    your exact train-loop code. We only add reward logging/plotting.\n",
        "    \"\"\"\n",
        "    # Your same hyper-params:\n",
        "    history_length = 4\n",
        "    num_hidden = 50\n",
        "    num_simulations = 40\n",
        "    replay_capacity = 200\n",
        "    batch_size = 64\n",
        "    k = 7\n",
        "    n = 15\n",
        "    lr = 1e-3\n",
        "    value_coef = 1\n",
        "    reward_coef = 1\n",
        "\n",
        "    # Environment\n",
        "    raw_env = gym.make('CartPole-v0')\n",
        "    num_obs_space = raw_env.observation_space.shape[0]\n",
        "    num_actions = raw_env.action_space.n\n",
        "    num_in = history_length * num_obs_space\n",
        "    env = GymWrapper(raw_env, history_length)\n",
        "\n",
        "    # Models\n",
        "    representation_model = RepresentationNet(num_in, num_hidden).to(device)\n",
        "    dynamics_model = DynamicsNet(num_hidden, num_actions).to(device)\n",
        "    prediction_model = PredictionNet(num_hidden, num_actions).to(device)\n",
        "\n",
        "    # --- Attach the chosen search mode to the MuZero agent. ---\n",
        "    # For example, inside MuZero_Agent you might have something like:\n",
        "    #    self.search_type = search_type\n",
        "    # and you check it to decide how to plan (MCTS vs naive vs none).\n",
        "\n",
        "    agent = Agent(num_simulations, num_actions, representation_model, dynamics_model, prediction_model, search_type=search_type  # << we pass it here\n",
        "    ).to(device)\n",
        "\n",
        "    runner = LoggingEnvRunner(env)\n",
        "    replay_buffer = BufferReplay(replay_capacity, num_actions)\n",
        "\n",
        "    mse_loss = nn.MSELoss()\n",
        "    cross_entropy_loss = nn.CrossEntropyLoss()\n",
        "    \n",
        "    optimizer = optim.Adam(agent.parameters(), lr=lr)\n",
        "\n",
        "    # -----------------------------------------------------------------\n",
        "    #  The training loop. We do NOT modify its logic.\n",
        "    #  We only rely on the fact that runner.run(agent) logs returns.\n",
        "    # -----------------------------------------------------------------\n",
        "    for episode in range(2000):\n",
        "        trajectory = runner.run(agent)\n",
        "        replay_buffer.add_trajectories([trajectory])\n",
        "\n",
        "        if len(replay_buffer) < 15:\n",
        "            continue\n",
        "\n",
        "        # Some temperature scheduling (unchanged)\n",
        "        if episode < 250:\n",
        "           agent.temperature = 1\n",
        "        elif episode < 300:\n",
        "            agent.temperature = 0.75\n",
        "        elif episode < 400:\n",
        "            agent.temperature = 0.65\n",
        "        elif episode < 500:\n",
        "            agent.temperature = 0.55\n",
        "        elif episode < 600:\n",
        "            agent.temperature = 0.3\n",
        "        else:\n",
        "            agent.temperature = 0.25\n",
        "\n",
        "        # We do 16 mini-batch updates each episode:\n",
        "        for i in range(16):\n",
        "            optimizer.zero_grad()\n",
        "\n",
        "            data = replay_buffer.sample_batch(batch_size, k, n)\n",
        "\n",
        "            representation_in = torch.stack(\n",
        "                [torch.flatten(data[i][\"obs\"]) for i in range(batch_size)]\n",
        "            ).to(device).to(dtype)\n",
        "\n",
        "            actions = np.stack([np.array(data[i][\"actions\"], dtype=np.int64)\n",
        "                                for i in range(batch_size)])\n",
        "            rewards_target = torch.stack([torch.tensor(data[i][\"rewards\"])\n",
        "                                          for i in range(batch_size)]).to(device).to(dtype)\n",
        "            policy_target = torch.stack([torch.stack(data[i][\"pi\"])\n",
        "                                         for i in range(batch_size)]).to(device).to(dtype)\n",
        "            value_target = torch.stack([torch.tensor(data[i][\"return\"])\n",
        "                                        for i in range(batch_size)]).to(device).to(dtype)\n",
        "\n",
        "            loss = torch.tensor(0).to(device).to(dtype)\n",
        "\n",
        "            # Initial step\n",
        "            state, p, v = agent.initial_step(representation_in)\n",
        "            policy_loss = cross_entropy_loss(p, policy_target[:, 0].detach())\n",
        "            # policy cross entropy\n",
        "            # policy_loss = torch.mean(torch.sum(- policy_target[:,0].detach() * logsoftmax(p), 1))\n",
        "            \n",
        "            value_loss = mse_loss(v, value_target[:, 0].detach())\n",
        "            loss += (policy_loss + value_coef * value_loss) / 2\n",
        "\n",
        "            # k unroll steps\n",
        "            for step in range(1, k+1):\n",
        "                step_action = actions[:, step - 1]\n",
        "                state, p, v, rewards = agent.rollout_step(state, step_action)\n",
        "                \n",
        "\n",
        "                pol_loss = cross_entropy_loss(p, policy_target[:, step].detach())\n",
        "                # policy cross entropy\n",
        "                # pol_loss = torch.mean(torch.sum(- policy_target[:,step].detach() * logsoftmax(p), 1))\n",
        "                \n",
        "                val_loss = mse_loss(v, value_target[:, step].detach())\n",
        "                rew_loss = mse_loss(rewards, rewards_target[:, step - 1].detach())\n",
        "\n",
        "                loss += (pol_loss + value_coef * val_loss + reward_coef * rew_loss) / k\n",
        "\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "        # -----------------------------------------------------------------\n",
        "        # Live plotting every so often (e.g. every 50 episodes).\n",
        "        # This does NOT change the update logic; we’re just visualizing.\n",
        "        # -----------------------------------------------------------------\n",
        "        if (episode + 1) % 5 == 0:\n",
        "            clear_output(True)\n",
        "            plt.figure(figsize=(7,5))\n",
        "            plt.plot(runner.episode_returns, label=f'{search_type} returns')\n",
        "            plt.title(f'{search_type} - Episode {episode+1}')\n",
        "            plt.xlabel('Episode')\n",
        "            plt.ylabel('Return')\n",
        "            plt.legend()\n",
        "            plt.show()\n",
        "\n",
        "    # Finally, return the entire list of returns so we can compare across runs\n",
        "    return runner.episode_returns, agent\n",
        "\n",
        "\n",
        "# ---------------------------------------------------------------------\n",
        "# 4) Run training for each search policy and then compare final results.\n",
        "#    Each call uses the same code above but different `search_type`.\n",
        "# ---------------------------------------------------------------------\n",
        "all_results = {\"returns\": {}, \"agents\": {}}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 700x500 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "search_types = [\"mcts\"]\n",
        "\n",
        "for s_type in search_types:\n",
        "    returns = train_with_search_policy(s_type)\n",
        "    all_results[s_type] = returns"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnAAAAHWCAYAAAD3vrTNAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAqw9JREFUeJztnXd4FFX3x7+zu9lNT0hPIPRejZRIr1JEEMUCIoKgIMKrgpXfq9gFu+9rwfIqWEAUe8ECiCDSQaQISAeFUCUhBFJ25/dH3M3M7szuzOy0nT2f58mT3Zk79557Z/beM+fcey7DsiwLgiAIgiAIImKwGS0AQRAEQRAEIQ9S4AiCIAiCICIMUuAIgiAIgiAiDFLgCIIgCIIgIgxS4AiCIAiCICIMUuAIgiAIgiAiDFLgCIIgCIIgIgxS4AiCIAiCICIMUuAIgiAIgiAiDFLgCIJQTK9evdCrVy+jxdAdI+o9d+5cMAyDAwcO6FouQRDmhBQ4giAszdixY8EwjOBfbGys0eIZyhNPPIGhQ4ciOzsbDMPg4YcfFkz38MMPy2q/Y8eOYeLEiahduzZiY2NRv359jB8/PiDdX3/9hWuvvRapqalITk7GFVdcgX379qlZRYKwLA6jBSAIInL54YcfjBZBEi6XC//73/8CjtvtdkX5RUq9Q/HAAw8gJycHBQUF+P7770Omnz17NhITE33fhdrv8OHD6Nq1KwDg1ltvRe3atXHkyBGsW7eOl660tBS9e/dGcXEx/u///g8xMTF44YUX0LNnT2zevBnp6elh1o4grA0pcARBKMbpdBotgiQcDgduuOEG1fKLlHqHYv/+/ahfvz5OnjyJzMzMkOmvvvpqZGRkBE0zceJEOBwOrF+/PqgS9uqrr2L37t1Yt24dOnbsCAAYNGgQWrdujeeeew5PPvmkvMoQRJRBLlSCiBK8brA9e/Zg7NixSE1NRUpKCm666SaUlZXx0s6ZMwd9+vRBVlYWXC4XWrZsidmzZwfkyZ0LduzYMTgcDjzyyCMB6Xbt2gWGYfDyyy/7jp05cwZ33nkn8vPz4XK50LhxYzz11FPweDzqVlwi3jlmK1aswMSJE5Geno7k5GTceOON+Pvvv3lphebAvfTSS2jVqhXi4+NRq1YtdOjQAfPnz+el+fXXXzFo0CAkJycjMTERffv2xZo1awJk2b59O/r06YO4uDjUqVMHjz/+uGi7fPvtt+jevTsSEhKQlJSEwYMHY/v27ZLqXL9+fUnpvLAsi5KSErAsK3h+586d+Pbbb3HPPfcgPT0dFy5cQGVlpWDajz/+GB07dvQpbwDQvHlz9O3bFx999JEsuQgiGiELHEFEGddeey0aNGiAmTNnYtOmTfjf//6HrKwsPPXUU740s2fPRqtWrTB06FA4HA589dVXuO222+DxeDB58mTBfLOzs9GzZ0989NFHeOihh3jnPvzwQ9jtdlxzzTUAgLKyMvTs2RN//fUXJk6ciLp162LVqlWYPn06jh49ihdffFH1ep88eTLgmNPpRHJyMu/YlClTkJqaiocffhi7du3C7NmzcfDgQfz0009gGEYw7zfffBO33347rr76atxxxx24cOECtmzZgrVr1+L6668HUK2Ude/eHcnJybj33nsRExOD119/Hb169cLy5ctRWFgIACgqKkLv3r1RVVWF+++/HwkJCXjjjTcQFxcXUO57772HMWPGYMCAAXjqqadQVlaG2bNno1u3bvj1119lK2ihaNiwIUpLS5GQkIBhw4bhueeeQ3Z2tu/8kiVLAFQ/C3379sWPP/4Iu92OSy+9FLNnz/bJ4/F4sGXLFowbNy6gjE6dOuGHH37A2bNnkZSUpKr8BGEpWIIgooKHHnqIBcCOGzeOd/zKK69k09PTecfKysoCrh8wYADbsGFD3rGePXuyPXv29H1//fXXWQDs1q1beelatmzJ9unTx/f9scceYxMSEtg//viDl+7+++9n7XY7e+jQIVl1C8aYMWNYAIJ/AwYM8KWbM2cOC4Bt3749W1FR4Tv+9NNPswDYL774wnfMv95XXHEF26pVq6ByDBs2jHU6nezevXt9x44cOcImJSWxPXr08B278847WQDs2rVrfceOHz/OpqSksADY/fv3syzLsmfPnmVTU1PZW265hVdOUVERm5KSEnA8GCdOnGABsA899JDg+RdffJGdMmUKO2/ePPbjjz9m77jjDtbhcLBNmjRhi4uLfeluv/12FgCbnp7ODhw4kP3www/ZZ555hk1MTGQbNWrEnjt3jlfeo48+GlDWK6+8wgJgd+7cKVl+gohGyIVKEFHGrbfeyvvevXt3nDp1CiUlJb5jXGtPcXExTp48iZ49e2Lfvn0oLi4Wzfuqq66Cw+HAhx9+6Du2bds2/P7777juuut8xxYuXIju3bujVq1aOHnypO+vX79+cLvdWLFihRpV9REbG4vFixcH/M2aNSsg7YQJExATE+P7PmnSJDgcDixatEg0/9TUVPz5559Yv3694Hm3240ffvgBw4YNQ8OGDX3Hc3Nzcf3112PlypW+9l+0aBEuueQSdOrUyZcuMzMTo0aN4uW5ePFinDlzBiNHjuS1od1uR2FhIZYtWyatcSRwxx134KWXXsL111+P4cOH48UXX8Q777yD3bt349VXX/WlKy0tBQDk5OTgm2++wbXXXou7774bb775Jvbu3etzKZ8/fx5A9eISf7wrW71pCIIQhlyoBBFl1K1bl/e9Vq1aAIC///7b50785Zdf8NBDD2H16tUB8+OKi4uRkpIimHdGRoZvDtNjjz0GoNp96nA4cNVVV/nS7d69G1u2bBGdOH/8+HFR+YuLi3mDu9PpRFpammh6oHq1ZL9+/YKm8dKkSRPe98TEROTm5gaNv3bfffdhyZIl6NSpExo3boz+/fvj+uuv963GPHHiBMrKytCsWbOAa1u0aAGPx4PDhw+jVatWOHjwoM+dysX/2t27dwMA+vTpIyiTv2tYba6//nrcddddWLJkCe6//34ANYr/tddeC5utxj5wzTXXYPTo0Vi1ahVuvvlmX7ry8vKAfC9cuMDLiyAIYUiBI4goQyx0BvvPxPS9e/eib9++aN68OZ5//nnk5+fD6XRi0aJFeOGFF0IuMhgxYgRuuukmbN68GRdddBE++ugj9O3bl7d60ePx4NJLL8W9994rmEfTpk1F87/jjjvwzjvv+L737NkTP/30U1CZtKZFixbYtWsXvv76a3z33Xf45JNP8Oqrr2LGjBmCizrUwHsf3nvvPeTk5AScdzi0797z8/Nx+vRp3/e8vDwA4M2LA6qfufT0dN9ikLS0NLhcLhw9ejQgT+8xb14EQQhDChxBEDy++uorlJeX48svv+RZ66S65IYNG4aJEyf63Kh//PEHpk+fzkvTqFEjlJaWSraKcbn33nt5IUG8FkS12L17N3r37u37XlpaiqNHj+Kyyy4Lel1CQgKuu+46XHfddaioqMBVV12FJ554AtOnT0dmZibi4+Oxa9eugOt27twJm82G/Px8AEC9evV81jUu/tc2atQIAJCVlaWoHcOFZVkcOHAABQUFvmPt27cHUB2gl0tFRQUvVInNZkObNm2wYcOGgHzXrl2Lhg0b0gIGgggBzYEjCIKH10LHckJFFBcXY86cOZKuT01NxYABA/DRRx9hwYIFcDqdGDZsGC/Ntddei9WrVwsGjz1z5gyqqqpE82/ZsiX69evn+/MqDWrxxhtv8EJfzJ49G1VVVRg0aJDoNadOneJ9dzqdaNmyJViWRWVlJex2O/r3748vvviC54o9duwY5s+fj27duvlcnpdddhnWrFnDC3x74sQJzJs3j1fGgAEDkJycjCeffFIwVMeJEydk1TsYQnnNnj0bJ06cwMCBA33HevXqhaysLMybN8/nCgWqQ7S43W5ceumlvmNXX3011q9fz1Pidu3ahR9//NG3WpkgCHHIAkcQBI/+/fvD6XRiyJAhmDhxIkpLS/Hmm28iKytL0OUlxHXXXYcbbrgBr776KgYMGIDU1FTe+XvuuQdffvklLr/8cowdOxbt27fHuXPnsHXrVnz88cc4cOBAyICxcqiqqsL7778veO7KK69EQkKC73tFRQX69u2La6+9Frt27cKrr76Kbt26YejQoaL59+/fHzk5OejatSuys7OxY8cOvPzyyxg8eLDPkvT4449j8eLF6NatG2677TY4HA68/vrrKC8vx9NPP+3L695778V7772HgQMH4o477vCFEalXrx62bNniS5ecnIzZs2dj9OjRuPjiizFixAhkZmbi0KFD+Oabb9C1a1de3D0h3nvvPRw8eNA3z3HFihV4/PHHAQCjR49GvXr1AFRbBa+77jq0adMGsbGxWLlyJRYsWICLLroIEydO9OXncrnwzDPPYMyYMejRowdGjx6NQ4cO4T//+Q+6d+/Omwd522234c0338TgwYNx9913IyYmBs8//zyys7Nx1113BZWbIAhQGBGCiBa8YUROnDjBO+4Nn+ENT8GyLPvll1+ybdu2ZWNjY9n69euzTz31FPv2228HpPMPp+GlpKSEjYuLYwGw77//vqA8Z8+eZadPn842btyYdTqdbEZGBtulSxf22Wef5YXxCJdgYUS49fG2w/Lly9kJEyawtWrVYhMTE9lRo0axp06d4uUpFD6lR48ebHp6OutyudhGjRqx99xzDy/EBsuy7KZNm9gBAwawiYmJbHx8PNu7d2921apVATJv2bKF7dmzJxsbG8vWrl2bfeyxx9i33noroP1ZlmWXLVvGDhgwgE1JSWFjY2PZRo0asWPHjmU3bNgQsm169uwp2i7Lli3zpbv55pvZli1bsklJSWxMTAzbuHFj9r777mNLSkoE8/3ggw/Ydu3asS6Xi83OzmanTJkimPbw4cPs1VdfzSYnJ7OJiYns5Zdfzu7evTuk3ARBsCzDsiIhtQmCIKKIuXPn4qabbsL69evRoUMHo8UhCIIICs2BIwiCIAiCiDBIgSMIgiAIgogwSIEjCIIgCIKIMGgOHEEQBEEQRIRBFjiCIAiCIIgIgxQ4giAIgiCICIMC+aJ6T8EjR44gKSkJDMMYLQ5BEARBEBaGZVmcPXsWeXl5sNmU2dJIgQNw5MgR3z6EBEEQBEEQenD48GHUqVNH0bWkwAG+rW4OHz7s24+QIAiCIAhCC0pKSpCfn+/TP5RAChzgc5smJyeTAkcQBEEQhC6EM22LFjEQBEEQBEFEGKTAEQRBEARBRBikwBEEQRAEQUQYpMARBEEQBEFEGKTAEQRBEARBRBikwBEEQRAEQUQYpMARBEEQBEFEGKTAEQRBEARBRBikwBEEQRAEQUQYpMARBEEQBEFEGIYqcDNnzkTHjh2RlJSErKwsDBs2DLt27eKluXDhAiZPnoz09HQkJiZi+PDhOHbsGC/NoUOHMHjwYMTHxyMrKwv33HMPqqqq9KwKQRAEQRCEbhiqwC1fvhyTJ0/GmjVrsHjxYlRWVqJ///44d+6cL83UqVPx1VdfYeHChVi+fDmOHDmCq666ynfe7XZj8ODBqKiowKpVq/DOO+9g7ty5mDFjhhFVIgiCIAiC0ByGZVnWaCG8nDhxAllZWVi+fDl69OiB4uJiZGZmYv78+bj66qsBADt37kSLFi2wevVqXHLJJfj2229x+eWX48iRI8jOzgYAvPbaa7jvvvtw4sQJOJ3OkOWWlJQgJSUFxcXFtJk9QRAEQRCaoobe4VBZprAoLi4GAKSlpQEANm7ciMrKSvTr18+Xpnnz5qhbt65PgVu9ejXatGnjU94AYMCAAZg0aRK2b9+OgoKCgHLKy8tRXl7u+15SUqJVlQiT8eSiHahys5gxpKVomvfXHMQve05iRKe6GPP2OjTLTkJaghOXNExHj6YZGPHGGrAAcpJjcaHSjeNnq5+lwW1y8dCQlrhr4W/4efdJX36fT+6KH3ccwwfrD6NVXjIm9GiIp77bhd8On8HgNrl4aWQBvttehKe/24mUeCdmXN4S7evVklWvdftP49rXVwMAejfLxDPXtMOirUexdt9pvDjiIsTYA43tZ8oqMO2j33B1+zq4rE1uwHmWZfF/n21FdnIs7uzXVJY8cvB4WEz7aDNa5aXglh4NJZW9q+gs/v3ZVsS7HGBZFifOliMj0YUXrrsIRcUX8NCX21BUfAFHii/g35e1wOsr9uFkaTnm3VyIuasOwOWw4estRwEAGYlOnCytQMOMBDgdge20s+gsAKB5TpJoHXYWnUVGohMZiS5f+pS4GBSfr+SlczpsqKjyAAD6t8zGidJy/HroDB4Z2gonzpaj+HwlHhvWWnYbLtxwGD/8fgxjOtfHGz/vw0NDWqJRZiLcHhZTP9yMv8sqAAA/7z6J1PgYPHdNO+SmxGHWdztxT/9mmL/uID5YdxhvjG6PF5fsxu9HS/DllK5oWycVP2wvwoT3NlbLb7fho1s7o25aPO5Y8CtYFnjhuovw3fYiPPj5NjTNTkTvZll4fcU+9GiaieeuaYe7F/6G5X+cwNNXt8WS34/hh99rpsB425RlgV3HziIzyYX0BCfOXqjCX2fOIznWgZILVWiekxRwHw6dLkNZhTsgL//7InSOe9z7WYyMRBcyEqsNATaGwS09GqB93TQ8+MU2JMY6sPd4KZrlJOGFa6vb4aUf92DH0RLkp8UhwekIKO9CpRsHTpWhcVYi7AzDqzcAnD5XgeNny9EsOwkMU3NtVpLL19d4GdwmF3tPlAbUgVuvuBg7UuJiUFRyAUmxDtRNi8f2IyVolp2Eg6fP4UKlBw0yErD/5DmeTOkJTmQmuXzyO+02NMxMwOHTZTj3T7s3zEwAALg9LA6eKhNtw+5NMmBjGCz/4wQAoFl2Es5XuuF02LDvRCkAoGl29T06WnwBxecrkZnkwomz5UhLcOL0uYqAPBtmJsBptwneP7uNQZOsRN4xKb9jf65uXwc3d28oOb3emMYC5/F4MHToUJw5cwYrV64EAMyfPx833XQTT9kCgE6dOqF379546qmnMGHCBBw8eBDff/+973xZWRkSEhKwaNEiDBo0KKCshx9+GI888kjAcbLAWZuzFyrR5uEfAADr/93P1zn5U//+bxSXMbZLfcxddYB3rGvjdPyy55ToNUum9UC/51fwjh2YNVhWuf4yX1VQG5/++hcA4Plr2+Gqi+sEXPPg59vw3pqDouXtOFqCQf/5WZE8cvhx5zGMm7uBV06osp9f/Af+u3R3wPEXrmuH34+U4M2f92smr9Ysv6cX6qUnyLrG//43zEjAj3f3wh/HzqL/CysC0hc2SMPOorMoPl8Jh41BlUd4GDgwazBazfjON2B7efn6AkyZ/yuA6udr2ke/CV5/c7cG+N/KyL0XQrSpnQKXw4YNB//mHV88tQdmfLEdq/eJ/9aJyGJiz4aYPqiFJnlbygI3efJkbNu2zae8acn06dMxbdo03/eSkhLk5+drXi5hLB5PzWe3yIAVLuVVnoBjRcUXgl7jDrwkbE5y3lhLy4UX9Jw6Vy543MuFSnfQ82pxrjywnFBle0Tun9sDUWVECu+PL+R933G0BE8s2gEAGNmpLgYLWCrv/fg3HPnnHl/WJgeLthYpLh8AKlV4IP46cx4AUOUWbosqD+uzDoZqL3/lDeD/foJdLvR74JKR6MKL112EOz/cjJOl1c/j++MLccNba0WvefSKVshOjsXEf6yCXq64KA/XtK/px/eeKMVDX24HAAy/uA6uLKgNAPhww2F89dsRANUWrG+2Hg0qo1emnUUlePybHSirqMKZ84H1evaHXXD72UPeH1+IGV9sw76T1fO629ROwda/in3nvVYmb1oAvrpnJDrRp3kWPtrwZ0j51CQ72YVjJTUy/W/lPvy0q9pydnvfJoIvTmpw16VN8XdZJd7+RbrCP6FHQ7yxYp/gueevbYespFgA/N/xiI75uLxtnqT8a9eKkyyLEZhCgZsyZQq+/vprrFixAnXq1FgKcnJyUFFRgTNnziA1NdV3/NixY8jJyfGlWbduHS8/7ypVbxp/XC4XXC5h6wsRHbDQyvAcmK/RNm7G2OJ1JVyHQrcmGbzvDntN6zXKTAg4DwC1Epw+Ba52qjk6fG8zeETaQ81nIlibh/qdxTlt6NYkA6nxMT4FTqiNuVyUn4oGGYEWyvrp/PuTHFczvDXk3LtVe2umN+SnxQcty0u3JhlIcNkBVCulQlMSvt9+DJ0apAVcl5nk8ilw2cmxPAWuVnyMT4Hzr3eteCeaZEl396nFW2M64prXVmPapU3RrUkGvtl6xHeue5MMzRS4Xs2ysO1IceiEHPzdpFw61k/z3V+7reaJb5Ah/DuORAxdhcqyLKZMmYLPPvsMP/74Ixo0aMA73759e8TExGDp0qW+Y7t27cKhQ4fQuXNnAEDnzp2xdetWHD9+3Jdm8eLFSE5ORsuW4vOcCEIv/N/K/dFOmYxcGEaZisGy6irMNo4cUmRSKjcXNeT3PlOiClyYYkqVMZQxkVGgSjJgePfFS4ydf4x/74TzsskoPjamWoG7UOnhKQRa4l8nPWhdOwU7Hhvom4/KRUtpYhxKngZpcO+/Cj9R02CoBW7y5MmYP38+vvjiCyQlJaGoqNr1kJKSgri4OKSkpGD8+PGYNm0a0tLSkJycjH/961/o3LkzLrnkEgBA//790bJlS4wePRpPP/00ioqK8MADD2Dy5MlkZSNE0a6rCCSUu9YoC52ebRAMJR2qmNKrtjLM6/ilpFe1dOV4WP5/f/S692Kubn/kSMMwEFSg7DZbQDovQgpf9TXSS/YqcOWVbtgZkegGAtUNR2FwOuzKL9YANV5QxHDY5NuTpMrD8D6b5VcaPoZa4GbPno3i4mL06tULubm5vr8PP/zQl+aFF17A5ZdfjuHDh6NHjx7IycnBp59+6jtvt9vx9ddfw263o3Pnzrjhhhtw44034tFHHzWiSkSEoJXVS0gZkzqIEeGjtjJsY4Q/c2H4o4Mp8FrexCxw4crJ/f0Ea/JQ1mdv28m9bUIKmcPvBnHTiN87OQpc9XB5ocotS/FrmFnj5qufLs1l68W/TsYQ2pKpBg4bIzv/YMn5Vjd96qA3hlrgpMxXiY2NxSuvvIJXXnlFNE29evWwaNEiNUUjCNUI6UIN8TP4dutRpMTHoEsj6fM2eH2USI9lZtctV2KWZSUPtCzCnwcnJomYDNzizPJ275sDJ/LyoJeUWiwWErPA2YIqcMIDuF2OAvePNazSzcpSAu4d0AzLdh6H3cbg9n5N5K3KNcfj5EPMkqkGDg3dxVZS2riYYhEDQVgFId0h1DygYIrU4dNlmDRvEwBtQ3mYGZaV3gGzrHxrTjCkWOC4mG2gENOfwh2Iec95kAYPpcAxfv+lUD0HTjwvLzYRC4xYmlB4XaiA+OpeIVLjnVg9va/0gkyG3GkESomx22S/AAV7jLV095oF2syeIDTG7VEeFsI/cKdUIqnvCtVpCw2VYkY29efAhZ79rNcApwTDFzGESOjV7+TcNYaRuqCE81kkjb/VLhguTpDnSpHftJmt2mqgtQtVzR+Q2MwGKyl2pMARUQktYjCPuy8Uclyi6q9CFf7sX6YXs40NWilwUnGHsFSJztELglTZGZ4LVTiNHEukzcb4VoVqFUfS7GjZZzgEQrOEQvqzwPksuxTzQgocEZVotohBIF8j+noTzqtXjJzmY6HuveUOWJGi8HIRX8MQpguV91m8vb/bHjyosVc+uS5UKfDmwNmE76NcnaHyH4U02LZRcoiEZ4pvvdKunBi7uq3Bl9WaixhIgSMIjbHC27reO+5xO1lZRassJyPBAsd/uzfX6CD27JllEPNa4ELdtW6NaxbwSJVd2hw4YxvC6i5XOThsNtnuTam/N7LAEQQREuFFDOZ0oYaC25nqLSO3YxZys4mJ41HZhSolAGgkulDDbSOuQh9OXqFcqMmxDqz7v77oylXgJOatdhgRKaj57LEwn7KhpcKrdtBivvWcc9xsP9IwIAWOiB50+N0K9d9VIRYxBH8LVzYiRFInpaaoLKuuTUP2TgwqlKmm/Fop3mplG8o4bbMxyEqOVRRJX1IgX5P/TAa3Ddx7V2/02sWAYeTbr4OvQuXnLeWaSIMUOCJ6MMjSZbQHVY0Oy8gqyFFC1JZTiuuFH8jXXKODqAXOJK47ZTs1KJgDJ3KJXltiKSEryYV4pwN1Je7XqgdaP94m+/mYHlLgCMJggisoyno0tftBvefA8cqWoWxouReqmBWHH8jXXGg2/5IV/Cgbr4IZqt2UWIHErKdilhkjELI5zbmpI7o0SsdTw9sCMI+yDRg/Z1AOomFE9BZEQyiQLxE9mPSXG2qr+2hHvgVOzVWonM8Snh+zjW9i+ptZ5l1KjQMnNp8pGPwQMOZcxCBE72ZZ6N0sy/fd6HulpO0VlyWzAMl7oZrYSh4OZIEjCBUxurP1onYfpWW1QokqK5Cv6qtQQ1vgzLwKVSvLKW8vVA0XMXhRYjWTFgdOUlaS0aK1zdKnABGm+4j8LiOpCqEgBY4gDEZr96SoUmHinowfRkRe+2gVyDcyV6EKHzeLUqAsDpw0pNw7KTsxpCU4JZZoTcTiqWlSltyttCTmpddCDL0hBY4gVETJfBWTjKVBMXLAv++TLfhow2FJadWeA8eIzKMSTa9e0aqgZKcDKXCzPXDqnOJ8pMaBU7KKkDcHTsQCI2Uz+29u7yatQI0wcv6pP1ooP2kJTnz9r26a5e+P2azk4UAKHEGYGm4sNlk7RqoqhZETqRdtLcK9H2+RlFZtOaVspaW6u1rFKmi1CpV79Rsr9inOR7ILlfdZuMG7NE7nfZcyv80mYQTMTYkLnUghUu6D0avYuWgxZ/CyNjloXTtF0bVSw4hYFVLgCMJggo9hJuq9NUJJRys28HlYY7fSMtugoZUFTi08El2ooVxgvZplonlOMv8aCaOb2gqJFtYyo1ehWmEFJ7lQCcJCaDauKcpX2kVKZVYlDpxOY0i4A6DackrZSouf3lyjg1gM6fB3Ygjvei/K4sAF0iw7Keg1YkqQ0fdLykuB0To4t3jt48DJnQMnnl7MamuuX2h4kAJHRA/mNkYQCN9dxII1dCsts2F+C5zUVagh5sAJHBO1rnGOS5kDpyWxTnvINFJa6LPbuoQvjAS0cKHqMSeNLHAEYSG0+hErGS7FxrALlW78fqREUd56dlKnSstx4KTyiexC8/yUys+y6urpcrfSMhvic+DCQy23nuQ4cArCiIgtYuBiN3gEfPbqtmiQkYAXrmsnmkaKjpvo0i6kq55Pvdyygs+BE1mFaiEbHAXyJaISzfaIVJCx2BU3vr0O6/af9svbmM4nWLXaP74EALBmel/kpMTKzpsXMkRCebyEGiN7Ky2TodlGDDob9kLOwxKQR1rgZbUX+8ijSXYSlt3dK+xclVSjZW4yfj9aEjKd1rdaK+uY6MIXE/9e5UIWOCJq0GMysJoDAld5Cwe9+qvfjxaHnUf4c7PUdaHK3UrLbIi6KE0mc8hnNMwwIuGkMRppz5f8erw+ur3sa6TEzdMTqdJIeRGLREiBIwgVUWSBk3iJ2kFE5HRkUpRfNVwT3nKUKkWs6qtQOZ916vnVlF+HrVB1yU9KGBF/RMO+cD4b7UKVgpR5gnKfzbv7N0V+WryktFqvQlVyb33pKYwIQRBGYqZAnVx4q/ikiKjialelSozaLSl3Ky2zIfZsGR2aQi4h3WxyFjHw8lU7jIiq2VXnqX6Wiss387MeDP6LWIRWQgBS4IioQQ89Scsi5MgvpY8yemAIBzHZWTbISQUwEswPJtW/AQDuCJkEFzIOnEAYiBi7wORJ7jUSfgNqr0LVYtWvlCz1Ukk0WYWqwD3OuTrIGbFFDNaBFDiCUBEl/bfUS5RaTRgGOFp8Hje+vQ4/7jymKA8tDXBClj6l46CHVde2FAlzpIJh9r1QvchZhep9YH6+t0+Ia/SfA6eNAifFhSrX9ais3lr/GlTNnxH+EuE/aR6kwBGEwWgxmPrPJXnw821Y8ccJjJu7gZMmhFzczzqN+L45cIqvVxdJcwlNPCBodd/01v+E5kkpWfHsj9pz8o1yoer1CJrJ/Xhbr0aSf3sUB44gIhw9Bh2zuFD9OXG2XD1BRFCjc6+xwClfxaCm0iLFQmM2axYXzeLA6R1GRMEcOCl5qY0mHmuDny89F/JIzf/aDnVwz4BmkvMKZ6GEmSEFjiBURFkcOHNqADzXpsz0SmH9/oumC6KYqNqaEd7Xu0W20opkzHxLtNkLNTRaKlZ6xoGTencbZiaCYaSrYuHNszMvpMARhIoo6uy0cKGqHHlcS4sLt3P1DoDhhBFRE2n7n6pbpppotZWW2oqKnCYUtPSa5B1oZ9FZ1fOUNAdOJ7XWLHNC1Q6TFKmQAkdEDbrM49KwiLDE16HjVaMINbZ4Uncv1MgeBkQtlSbz+6od49CYzLRBiltWy8dU6zhwvLJkzmkL9vvkWd3CEcrEkAJHEAajxVCq+jZCkkIZqGnpUxgHjlV7L1QVMzOASAnkK4ew58BxErsc5h8CjZ5ioXUcOCX9RjgBfyP9pYyL+Z9egtAArbpEJZ2t9J0YlEst1GWpYYXh5qFKvxhmGBH1V6FGdmev1U5aahvwZLlQFdwTsd9OSpxTdl56o8kqdYWPtdbKj/Q5baHTiy1ciOxfNB9S4IioQZdVqObyTFWjimtTzBUXft78xRLSwoiIKiasuu5BI17W1XyGjLbeSEWWlIJvI8rLbpKVqPxiHTB6EYPWq1CVWMe86SiMCEFEIVr9hpUF8pV2UTgDe7idlljZak+SDzeQL0uBfCUR7m0znQs11DWRbHeRNAdOu/qZ8RUgnPiMEf0s+EEKHBGVmKlT0mYze306Kd78GBXzU2pFU92FGuF9vSktwgLIc6GGl0GkWWMixYqqFCWLJGoWMQTLVzh0SCTcc6mQAkdEDfosQjVnZys471tGTyZWK1ZlDc4XRiSc61W8BZa1wIV7vYGaoZUmoUtBi71Q5bzgmXIVqrZiRAyGKnArVqzAkCFDkJeXB4Zh8Pnnn/POMwwj+PfMM8/40tSvXz/g/KxZs3SuCRFpaDUAKdk8XOoVSmVWxTImUjbXharKKtQw01XrbyrOgVMtJ2WwLBvWhvTmfJ0IDzn3JD8tDgDQpXG6NsLogJRpCpGs0ypyiXvnwAXbzF5kbl0EN1UADiMLP3fuHNq1a4dx48bhqquuCjh/9OhR3vdvv/0W48ePx/Dhw3nHH330Udxyyy2+70lJSdoITBAhWLLjuOxrzBaTy0jCngOnnigAjB8Yx85Zj51FJVh+T2/ExtjVy9hkz5ys6QEy7snSab1wvsKNlPgY2TKZBWm7oOjzoGq+ClXBogRJ6cO41swYqsANGjQIgwYNEj2fk5PD+/7FF1+gd+/eaNiwIe94UlJSQFqC4PLXmfPwaBUUSyf2nzyHNrVTFHWi4Xa8Yi3Hs8ApLILlfWZ5/2Xnxaqrmxjtrlv+xwkAwOp9p9C7WZb8DDTbiUGTbCUhR1lxOmxw+sV609MlqAZGhxHRfistrnVM4irUgA+hyhC8OuKJmDlwx44dwzfffIPx48cHnJs1axbS09NRUFCAZ555BlVVVUHzKi8vR0lJCe+PsC47i0rQddaP6Pv8ct8xMxkgpIoy9OVfMOu7nRLz5OeqpMviKVZBwnaEC88Cyfr9l5uXyjsxWBWzNZG8rbQCjyXHGmthm9y7kaHlW8mqJAkJFRbbTtBKbRUxCtw777yDpKSkAFfr7bffjgULFmDZsmWYOHEinnzySdx7771B85o5cyZSUlJ8f/n5+VqKThjMd9uKAAAVVSbd2VvGaPr68n2S0nnrDHjnksoVShr8OXDhE0x/4yp6WiqURhMJdVB7sY7S3J4e3hZ9mmfhpq711RRHNnaDtQItS9fVYilzEYPcVatyrokEDHWhyuHtt9/GqFGjEBsbyzs+bdo03+e2bdvC6XRi4sSJmDlzJlwul2Be06dP511XUlJCShxhKdTwFvMUJrFAvpzPSt2NQpY+ISWGZaW9PZt1JbARSFo9HGFwn4FrO+bj2o7G9912m8G2EA21Es1dqEqukXCR2O4LRk+LUJOIsMD9/PPP2LVrF26++eaQaQsLC1FVVYUDBw6IpnG5XEhOTub9EYRR6KFwaDXJWaoisOXPM/jPkt2odAdaQfkeVPEMpazG87DmcaF+OaWr4HErjB+RtpUW73oFkf9DYY+IkbQGsz6Cki1q8O7EYNaa6ENEWODeeusttG/fHu3atQuZdvPmzbDZbMjKUjDhlyAMwCwKhz+s6BfOYYmLGIa+/AsAwO3xYFr/ZqIl+SxwAgVKaSYj2lKszLZ1UpGXEosjxRd4xxnoNwdNfC/U8CRQW36tVqHqhc1mtAtVu/I1X8GpaCutgEtF0wSUIVkw82OoAldaWoo9e/b4vu/fvx+bN29GWloa6tatC6Davblw4UI899xzAdevXr0aa9euRe/evZGUlITVq1dj6tSpuOGGG1CrVi3d6kFEHmZVmrRArMOS05Gp5YpbtK1IQIELLEfMhQoAh0+X4e1f9otcX6OaNMlKxO7jpfIE1AEbwwS1JgopV1YadMLFjG1h+By4CHahKkHSVlq8z7SIQXU2bNiAgoICFBQUAKiez1ZQUIAZM2b40ixYsAAsy2LkyJEB17tcLixYsAA9e/ZEq1at8MQTT2Dq1Kl44403dKsDQYSLLsqkgk5LilxyFzEU+Vmj/MsJthODt6wp8zeJ5s8NI9K+nj4vcXIHhFC7O+ixmX3Ye6EaGUbEhCOwXYYF7toOdQAAk3qpt3LVfC0iHbG5akGvkbCVllB6OddEAoZa4Hr16hUyiOmECRMwYcIEwXMXX3wx1qxZo4VohMUx00R3oyQJXa6EVZ8yyxTqO4UXMYjnfPB0meg5/qIKWaLph1nlihDUbD618pKjwD15ZRvccEk9tMpLUal0+UqtnORiliwtkL6VlpQwItbcfYFLhE29JAhCCeF2YGIKL9cCp1QRFXSXBkkXrC7VabxXq9NtN89Jgt3GoGP9NFXy03Mw0SrcitovQOHGgZNVlgaavRwFzmG3oW2dVFnXhELLZ0r7QL5KLvL+kzpnzpoqXEQsYiAIK6P1VlpifVeoLk2SWDz3pxRhlJfpVRqCd8Y1q1DVGh+/ub07Kt0e1bayssJYovYjK28Rg/kaMJRbnJCG7J0YJKax6t0hBY6wPEKdQjQtYgDCVxqkuFCVKqJca47vs0BWUmLbcUVQa0y12xjYbertQxpqkBJqRjVi7Ek5TihDTWuaEuTvDSr9Aq1XoSqLA+cNIxIsjTJ5IglyoRKWx0zz3YQwq3SsyGcuUmKzhSxHwIonGEbkn5OhXKg1DlRz9uDRMLDIxagmUVPJNxKzPuty8b8fPZtmCqcLM1+rQAocEZWYSWmSqwMVFV/Awg2HUV7l1kYgGQhtYyo7D4HPwebFBeuMqwP5Vqc0eEwVJaTrWsWn078dvW2ntds+GHECrmgz/R6VYHQYkUjW34JtcyU6/UNSHDjuIoYIbqAgkAJHWB6r/Xgv++/PuOfjLXhp6Z7QiVHd2SlpA6HwHv7wFjFIGIUFV6Hy8mBF85KSP38Vqjnvu5FyqVVyOArgoNY5KkmhDmqEmzHaAqclRirXojEsZZvgwpXEnJACR1ges7tQ5XaRp89VAACW7ToeVqlineAXm//Ca8v3ShqkpW6DJRXW7z+/rNCrS7kuVLOiyuIRiZjy2RdoACPH138PboFezYRddVIxfCcGuXPgzKrQ+MkltjjE90KqIA6clSAFjohKjHQh+aOHKEIdmFi5dyzYjFnf7sTvR0tCppUreyjrU9BVqJIscNxVqPr02pe1yQUA1EuPl3aBgYOJWta/cJ5Zs1nEk2JjcHvfJmHl4TBagdMpb20WMYi7OkO7UNVbtRqJ0CpUwvKYbcCIFE6WlodMw7PwKBzU+cqA14UqsIjhn/8hooj40Oute0L3hmiUmYiO9dPwwbpDIdOHngOnIv5z4LyHw44Dpy9qvuTw51z9s5oxzDydBu9mr6VbXmrTM4wWL6PUdweDFDjC8kjdGN0oq5yaAXCFYMAoUmaq3GLbMLG+AcN/EQP3nFR4YUTEo4hIc+lyrtWr63fYbRjQSvq8rtBWyMB6qlUXM7iSBK3B+ovBI1wFyBVDziwGyu5jsG2uxC1wocOICKW3GvTUEQQAj4fF1a+txtg563UvW2u9MZQbQoxKd6BiNX7uegx7dRXc/wRl4y5iGPW/tRj55pqgilaoMh/6cjuvPC7eOHDBw4jUXGjWPpsrV+eG6WiYkaBZWf7N6LU4hTs3Tu93Ha3vZaRb4LSEHxBXvKXUUJICVqFKTCc3X6tAFjjC8khxoR46XYaNB//WQRpjUOJGrnR7fJ+r55axWLqzeuHEH8fOokVucoAasGbfaZw4W46s5FjJ5XCVgVV7T/lKDEjn24khSF7gxIszqQbHlSo2xoa81DjsO3nOd0xT3cgETSIkgtFihfOoPHdNO7hU2qVDKVq2n2QXqsL8g10nuohB3hoG077MhYt1XxsIIgj+FgQjXTh6rBRU5EL1eHjf3Z5Ai1ywuWpSkRwyxKCdGNTGX7HUUk4xa2i4FrT//bwvvAz80PP3x5s0LzAZXihOnRg3XFIXw9vXsbQFTipqPMdSfxtyX0itOg+anjoiarlQ6cbPu0+gvMpt6M/bRAtieXBdqGUVbrh5G9eLx2uTuzuD1NQ1LlTxu8Ut2z/dpF6NZMllFFo+D2o952fLq5TLYMKxNNg8rGB4A/g6HUYvYpCbvvqCmVe1QYcQcfCkrkJVrCQFyTTkKlSJFTfjM6cGpMARUQqL+z7ZgtFvrcODn28zWhgeRnY2XItNFceFeuv7G+FnkAMgvD9psD1LpVZN2AAn1YUKwXQd69fC5hmXSpRAO2w8ZUHbmy26E4OmpcrHTOOrEllcBitwShnZqS4+ntRFncxUscD5ZymcqYXjJssiMp86glCBLzYfAQB8tOFPY5Umv+96xS8TYu3+077PlRxN7OCpMsFdF4Tcvx4pu85z8HfzzfllP3YVnQ1IN3fVAewsKgk4zs+sRib/Tt7GMCZxpfi7ifxl0k69MkP9hWQwWqFU+pPz3jujFTi97qsWpTAin4MXKG8VqlWhRQwEYTD+CkywPokba0nOoCfV0jPijTW+z5VVfnPgBBQ4IatcMBegkBz+yR/56nfBa19fvg+vL9+HvJTABRLeduEqlP6Dmq16TzHDCbQyaEfAKlSvBc6sfnuD4M+Lk39HXA5jFzFoidaLGIIRahGDVKyq6JEFjohKzDx+BbPA6Wmdq/KzpAlZ1gQtcBIb9+9zFbhn4W9Yz7H6KcXbLiwr7kK1Mcri4alNKBGEmk8tuU1QfcG66CmXYPlct3aQa+ffXCh4PMZhbMvKVmhMIIOUPEKFEZG8CtUUT776kAWOIMxG0InCqmcpCjeMCOC3CjXIIgZ3EAWOK8cTi3bg441/ypZLyEJiYwA3/BU4PwuczZwKjLarUP3L+kfR1a7IiIR3D4Lcj9q14gSPa2mBu6qgNj799S/N8g8FfxFDkAUHCn9d/CwlrkKVHchXvlyRAFngCMsjJfK7kW9o/oNssAm6/nV5Y8VeXD17laJyQ9XYfycGrgHuk38UL0EFTuIcuIOnzoVOJBGhALX+9TNybiGXgP0e/c57a6CFm9MMLWCS28CDvx+ntHRc7DYGU3o3VlmqamYObyNq+dMDOVtpqU0oC1y4+UQ6pMARlsfM7lIg0OUYTNHgDiAsy+LJRTuxQaMAxP4WOK6c76w+WC2DQPcutgWXP2quwPRm5eHMgxN2oYqXOX1Qc9XkkQoDbVeiisYYNNlvwihxvE2vxsrg+hrtqOFy2NGlcYYmeauJcu8Ad/4h/1zoOXDSSjVrUO9wIRcqQcDo0B3870FFUbxaLpQMgXuYVvpZ0oQsa8JhRPgHxSxJSkMBCNXFbgucA+ff+duDuFA3PtAP6YkuZQLJJPS94P9Xt3AN8pSNwfPFhI4xwp+DpTMTWk7ql+hd1kZJEnWhqpJNxEMKHGF5BF2oJrJA+Cs8weeZyEesrqxfGv9iq4LMgau5TsAC57/4QWR3BLuKwZy8AVWPFp+vmQPnl4YJsohBL+UNEJDL77uWK0S9ZZno8QdghgE2fAmMr4M2aL6VVpAFJGIua+9xsyrUekEKHGF5zKSsCSEW6kEIpfO4lFwVOAdOmgXOHWQLLi6K6yJwme0fZXD7kRLRdGaJA8dV0EMFJQ4XsUUMRiJlTqreSF2FqucCFDmo9VynJTjDESJsJG8zp6HFMZKgOXBEVKLH/qOSCVjEEMQCp6AjEqsrw0sTSKXHfw6ccO7+HC8p97tOpHzFyqjwKtRQ+dsFLHDNspPw/njjJogLYaInUxPMNJZ6nxE7T6kO9vszk/TK8a/FF5O7onuTDMwTWCzBc6HquFAh2DlG4HzznCTRaRlWuW/+kAJHWB6z/3YDXajiaZW7KYJfKegK9bPACbtQA/OaNG8T7zu/fjVyqLkdjpA7Voq1ZN4thejWRN8J4raAXle4ITRZhcpol3c46PkTFXoOHHaOAhfsWpn56kWosq8qqB30fLv8VLw3vhAtcpMDzkl9UtRY5e2fg/gihsDj/xlRgIk9I2O/Y7UgBY4gYGzn668XBbfA1ZyTOgZLSSdogQuyCrXmmHB+//t5H1b8cSJoGrtSC5yQC1XgoL+lTkjJy9Bx7psXvlyBVkGhnTbUcpGZ4V3GjC9UDo5WzZXv88ldeenMKLtZUNo2wRaQiOXp/Slb1bImFZoDR0QlZjJA+Ls45cSBU00Ggfao8N9KS+IiBgB4/JsdAIADswbzFD9+Z63efD4h5UxwL1TOse46W96MIGCbNgrkKwjXAsd9wi7KTw16nRnmVAISFPMwxOS7UPWtr2ggX4EKRaMuRxY4gjCYQL1I/VWoQtfxrHlgAwZ7fwVOjgWOl0Z0EUPoa6UiaIELUODMMeCG2i4o2C4XYZetfpayMdNm9l5JHJyH0X8RDj+9GVowNA0zEhBjD9KPaKDtqDG9I7B9hXP1WeAUlmkVSIEjohJTWeACAvmKp1VstQpxGTd+mpdyfxeqwLgmZdcFtVehCmUXOK8scDCw2fgWOKN2ZggYojQUQ3wze+3K1IJODdJVy0tICXPYax4g/zA4vGsNsI5LIaBfYIDL2+YZK4OiPIJ/rzkReD4alTlyoRIEjJ1LERjqQTytslWogFD35q84+lvYAlyoAqN+WUVVyPIrOYshWBZ46Itt2Hz4DDKTYkNeK8Sh02UBx4Tm04WK6m7ULQ+Qw//e+ObAaRfJV6gN9UKo3UPdigYZCfjxrp5IT9BmziLXAidmMQaiU0nQOg6cEiLFEqo1pMARhMEEWuCkuVBLy0MrT3IIZUwTsqSdr3SHzJe7GIJlWd82XDamWJ6AQRB2ofpZ4Bi/+Tyqla4cqUqkUmUzUixtUsRsmJmoWfncOZTBLHD+D41Z5l2FEkMPhUfPECM1LlSO+9Uk90JPSIEjohJ/64aRv32lq1D/OnNeUv7V22SFSgN4QgyjQnPgyirkKXDcPCTueS8Jm1AYEf80TPC9UHUjhBJQs5m9BkWbr/qmgGeBC9LwwRQhM1mFQip0MkSVnlS/+pvid2wCaA4cQRiMnHFazYn/x8/WBNytXsQQPD3XteS1WIRS4FiW5Vk0xLbVChehdglYhWrzC+Bh0jlwaipuZnpRCYZRcnnbnvssKJ0DZyR6zqNUW4ZgYUTEyq4JI8LLSZkAEYyhCtyKFSswZMgQ5OXlgWEYfP7557zzY8eO/Wf/wpq/gQMH8tKcPn0ao0aNQnJyMlJTUzF+/HiUlpbqWAsiEjGTaykw1IN4WiVKh39VveWt2nuKcyy45QHgz4Grnx4PACgL4cZ1e1jeXDpeSJGgV8pDsguV4X83AiOtB2ZQQIy2nkixRoteq64olkKNtpFqxRScRxmFN8dQBe7cuXNo164dXnnlFdE0AwcOxNGjR31/H3zwAe/8qFGjsH37dixevBhff/01VqxYgQkTJmgtOmExjNTn/BUnqXPg5MANKVDhDlxOygrI4Q93Fao3aVmIOXBVHtZvDlzNOTUHcik7MQQudDBHj+8/aKkZRiRggYxJ6mwVzNKacn9LclJLTavYAqegFY1+CTALhs6BGzRoEAYNGhQ0jcvlQk5OjuC5HTt24LvvvsP69evRoUMHAMBLL72Eyy67DM8++yzy8vRdRk0QStB6FSpYwMkJk1BR5YHLYfeTgQ29iIE3f6368/kQLtQqD9+Fyl0IoWYXLKzA+a865c+B02IMaJSZEDJNQLES5FBLVBr3wiP4Pqk6CqIjer7cSl7UI/GY1TH9HLiffvoJWVlZaNasGSZNmoRTp2rcPqtXr0ZqaqpPeQOAfv36wWazYe3ataJ5lpeXo6SkhPdHRDdG7g05e/le3vfgLhxl3RQ3zlV5VaAF7oN1h0K2gf8CBJZlMXfVgaDXPPTFdpzgzLXjKXCqzoGTsogh+Hk1GNAqBw8MboGPb+0sKT0jIEfNVlrhP5MBceBkXn9O5ZXOZkPu7ykalQSpKI2rGHQrrRBlWVVploqpFbiBAwfi3XffxdKlS/HUU09h+fLlGDRoENzu6rf+oqIiZGVl8a5xOBxIS0tDUVGRaL4zZ85ESkqK7y8/P1/TehBEMM6UVfK+Bxu4lcWBC4zv5h/r6slFOwVdq1w8Hr4FbumO4yHL/mTTn7hzwWbf98ogUe7DQWg+W4AL1eZvkVNfDoZhcHP3huhQPy1IGvXLlYpc19NzP/yhgQyqZ6kbkSy7UiS7UDWVwq8swd979N0cU4cRGTFihO9zmzZt0LZtWzRq1Ag//fQT+vbtqzjf6dOnY9q0ab7vJSUlpMRZGKGftb+xyUyLGoKhtIvi1q+iyiM43628MrhyxbWesSx/FWswKsTmwIGBWg4a4b1QA12owc4bhb9caoYRCTePHUf18U5EyM8vwGJnkkdIPiYSnLcyXGIP57PARblN1NQWOH8aNmyIjIwM7NmzBwCQk5OD48f5VoCqqiqcPn1adN4cUD2vLjk5mfdHWJdIGRy8BBt07UH2NwyWH9cKV17lEdxVIZQFzu1ngQt7DDDahWrUKlS/4KNmHoIqQzwTSojoQTeCRdcaIyxg0b6VVkQpcH/++SdOnTqF3NxcAEDnzp1x5swZbNy40Zfmxx9/hMfjQWFhoVFiEkRYBFPg/BcfSOHRr3/nabHvrD4guK+p/9ZZ/pSLhANRivaLGIKnMasi4Z2LqM6Lh/QQNUJoocAJYXQcOK3SG0WkuhOlim0W67nRGKrAlZaWYvPmzdi8eTMAYP/+/di8eTMOHTqE0tJS3HPPPVizZg0OHDiApUuX4oorrkDjxo0xYMAAAECLFi0wcOBA3HLLLVi3bh1++eUXTJkyBSNGjKAVqIQPQRdqmMPjZW3ELbxqILa60+WQ/5Mtq3Cj+HzNPLv5aw8JKmChBmt+PLfw46hpvoghlMvUBGMAA0ZXpUBuWRVu9e3XQjLou9JRuBFu7FwPGYlOXNoyW/xarYSKIMZ3ayB4XJVAvhLzrAnALL38/i2zkZ8Why6NMmTLaFYMVeA2bNiAgoICFBQUAACmTZuGgoICzJgxA3a7HVu2bMHQoUPRtGlTjB8/Hu3bt8fPP/8Ml6tmQ+N58+ahefPm6Nu3Ly677DJ069YNb7zxhlFVIqKEh4e00jT/Do8vFjweGyPfAgcAS3fypxoIulBDWeD89jQN14KlpgVMylZaJtTfAAisQvX+V8HKGW4cuCpNXKjm5NErWmPd//VDeoJT0fWRZPUKR9IHL28pnKeO1VdigXt9dHssv7u34j7UjBi6iKFXr15BO6nvv/8+ZB5paWmYP3++mmIRUYCZFzGwLItzKlrgBMtQ4kLlBO0V2theLmp2+EJTA/0HVP9AvmYfcHktrJKo5EINjtCLABf/Z0bN/XzNiuSttBTeRSUb0vsscNxrQ5RfHQdStnimJqLmwBGEadCwIwjWYar19ihkgSsP5UJ1812o4bZBqMvlWEKEV6H6leevwEnOXV24YtRLjw9UJNXcCzXMvCp1cqEahVxRAqy6agliAdS5r1JXoapRVuRDChxBQJ2gqWoRfBGDOj9ZIQtaKAuc/56m4fahYlZGL3IGBCFrGvdQ72aZusSBk8vtfZsIuFDV20rLH7lVDrUyORIxwW03HFm/LZXTBVyn6EIm4Foz/J71hhQ4IioJd2zUcgVjsBWeQpYmuTgdNsGpC3JWobKs9i5IOQqMYCBfzj0a06V++AJpQILLobE1138VqrzCNAkjIiCDeV6flGNV/UGyC1WF/kD6KtSwi7IEpMARBMw1By7Y/LJQe49KglW2iEFtC1wohGQUI1QYEaFJz1UmncDkq7YJLHCVIZ4JglATydY+XyDf6IYUOCIqCXeFn5bGp2BWD//VpEpgIbxxfSh3WYACp3Hv6ZYx/ypUGBGh80YpJ4Fz8bRryIDHXHYYEX1WoRo2EIdZsDlfAQIJ57cqXalSXoZ42cKZStk6LxogBY4gIL8j1rKvUGOFZzBYFgF7oQLA9E+3Br2uvKrG+udhte8w5VjIBC1wnM9CHb5ZLHABaxhU3Mw+oCyZ6bVYxCCEOe5EaILJGUkKhJyXBumrUJXBfaGR6oZlBObARSOkwBGEydBasWChTEm8UMmPA6c1arpQhQYGvUJkGEmAAc4MI57BIoTTBPF+q8BN0JpRSc09lK/8WQlS4IioxH9gk6uQaNlZaG+BY3kLJdrUTpF0XVmFnwVO4+FLTjsIbTFm47lQA68xiwInHshX+7LMglnl8sdmY9CtcU0k/0ixHIaD3Hlp+pQVdlGWgBQ4gjAZeljgvApcanwMHEJRcAU4X1nl+xxqDlxmkkv8pETkKXCBXRnPhSqgwenlHgyFWDtypVOiLF+odGP/yXPKhNIQs+5BKxW1QvloSagW1ma+WvjXyd0LlTazJ4goJFzrRiR3FiwLeI1PdoaB0y6tG+Ba4EK1X+9mmfjl/j5KRZSNoALHW4UaeI0W20QFyhB8bl71d/4RtdzTV7+2ChsP/u0njypZWwYlyqRYmB8zK6Z6rLI3856+VoUUOIJAdLhCuHgHIYZh0CgrUdI1/iFMDpwsC5reoWOwJqegAhd8foweFrhwlLFwFbltf5UEHDODkmH04Btu8dHWV0hF8VZaPCua1J0YAsOIGP1cGQEpcAShgEjvLLzuSbsNGNe1vqRrzlVU8b6/sOSPoOmVbDjNJdElfavmkC5UEy1i8BdFw520QpZNyMcki5dNhxrPVqjfhu94+EVZAlLgiCiF3wubKZCvHizdUR1Pzs4wSI6NkXSN3CDC4e4a0aZ2CqYPao5hF+WFTCu0iIEJsYjB/GFErEmkD75cyyi339BaOf5hag/V8jLTPVAkyz8X8azspqqVPpACRxAKiPTOwms9YxgmQPkRU7xkK3BhjmhuD4uJPRuhU4P0kGmFXKg2EddMw4wEAED/ltlhyReJmDXUglHKqpLmMOplr2l2Etrlp0pKK9WSJQUjXyTE2lo4cLfGwpgQ6T4KgohAPtn4J55bHOjqC+wYrGrvCI7dxgQoP3aGgVugPUJtPu+PjZNt3+ZZqJeegLd/2S/5+ipPtYvzzPmKkGmF58AJf/7o1s5YufskBrbOkSyLmgQONMKBRLjPqFpBfc0wxhk90IarxHLvhdF1MRNK2zXYdaFcqNHe/GSBIyzNXQt/0yZji/QcQgpcqLrFSAw7wrXkXXVxHaTESXPVernhknoAgJ5NM0OmFVpJy7W6cWXJSHRhWEFtxMYEul2NINpW7wlZr/UUK9zFITzFOgre+yTHZlOjLJlhRNQuP9IgBY4gIL8jNsNAqAYME+gyDVW17OTYkPmyLD9fh50JGm/Ovz0fvaIVriyoDQBolRc60LArRroFTk+Ew4gEF0ZwKy2LKwqRVD2xviKSugQ5vwfJW2kpbIBQO6YEu8Yq/bBSSIEjohIzDhhxBliElMxTy0iUFqSXm7fTbgtqufN/o762Q74sl4ygBS7EZvZ6IMXaIyqZFjsxmGDAM4MMXpSIImeLt2hCX0uyN4xIdEfyJQWOIGCOzezDXbWpBCHFJpSykxQrbeostz4xdhscNvHuxr/qct2bLoH0/DAisrLTFSlhRNRSGcy6+EZPqcJeyBFl+pt0F6rCOXBByhLL0UwvAUZCChwRlZjxJdoQBS7EJvBCJEucy8YdKGPsjCwLnFyELHDcPM26+hIQH/i0eETN0AwmECEsxBaUmKFtpaKFIi+1/s2ykzCwlfACovC20oqgG6ASpMARhAK0UAi03rkgwSm04XtgulBSJEuwwPk3T0p8DBxBtuwKV4ELNQfOKBeqEsz4cmElVF3EEG3muCBI+YVlJbnw/dQeaJmXrHlZ0QCFESEImGPQ1NoCJ6R0CsdTCuVCDW2B87bng5e3xPGSC2iek4ytfxaLpg+36qF3YggvfzWRqktqsdrRFM1gImVayYuYlFtROzUOr49uL1+gSEZCWwq2nYJgvBQHrhpS4IioJNy3cC36Cq0tcEK5C3V6oTpCOYstxndr4Psco6UFTkCBUzN/LQmcA6fh24SJ2yFS4G5mL6Zw/HdkAVrXDr162kpIebK8/W64c9voMa6GXKgEAXO4QuwS46spRVhZkx9PKV7AFSsFOWFE5CK0lRb3jporjIg0uM+kpQL5Gl1+uIF8RV2oRteshpCWLA1EVRxGJGiewmeFwoiYp/X1gxQ4IioJdzjUQiEItkpTDQQXLAikCzXAKVbggq1CtTHo0zwLAHDDJXVl5y20EwP3WK14p+w81UCJpVdLd75ZLRd6vj6FPwfO+Jc9MyLNAvdPWpHE/ofF2joaFywIQS5UgkB0zIGTOm8k1CAvZO3yR6g5Q61CfWlkAdbsO4WujTNC5h8oU6AC57Ax+PaO7nB7WCS4TNTV+TVwwKDl/a9FHDj1s5SNmZRIJaJ4TNBXRCpCTafkefB2ldzfiJlXmmuFiXo1gogctHgDNGQOnMCxUPPFhKxdUgimoNoYBgkuB/q2ULbBvPBeqAxa5Ia32s1IuIOdaosYTDrImVMqYaSEETFpM2uKnGdr74lzIpkoLysKm5xcqER04j8gmsECFy6hJvILdnr/HOPqVqE6QikKnFAewRcxhMwyKMJ7oUYG/vfF6i46o91fas6Bi1TktIDkrbSk5PVP41VUeTjXKVmF+k/6SPmRawQpcAShAC06jp1FZ8O6Pi81Luh5IZm9HeF74wuDpuMSSlEUI5iFMZTV75mr2wY9b0QQZKVIXsTAchcx6Fu2lQlXQSYXqjBS+kThXUbEG1R8EQOFEQFIgSOiFP9OwwyrUMMlVAcmHLS3+iB/3pk2LtRggXxDyX5Nh3ysur9PkOupQ5eCGdrEDDKEQ614aTuRWAWpt0upZZU/j01RFlELKXAEYRFCbUwv2MEq6DCVLmIIhhQLmtw5gka76oDw3HXaLGIwvk3MhJLb8/iw1sJ5iXw2I3KeS8mPoRQLHOvNU9i6HKoPC1682VtdfUiBIwgFmPFNMZQbUnDFqWA+wctRaoELJp4UBU5ow3qzo1YYEdXmxZnguWUANMxIAADkpsTqX36YP95QUxWiFTlz4PwO+j5qHQvTapACR0QnFlzEEGpckrrilGGARJGwG3PGdlQ8B64gPxW39WqE/LTAAVCKApcSF4OWMlaVmlHJBgLl0lNOMzQJwwDvjOuEUYV18cEtlwCIrDhw0YZkF6rCh0stC5wpHm6dIQWOIBRgRnO9ku2ihC5hWWBUYWAw3Q8nXILezbPCsMAxuHdgc1zWJjfgXIzEIMY3da2vqOxIQmg+ptVUjvy0eDxxZRvU/8cSZyYK6qYGPS8ahNZEbwxGiCKlTxSKccj9HEmLkcwAxYEjohKzD4gNMhKw/6RIrCQRQulAUif6syJp453V3YVSC5wvf4HGF9olQggzDZJao8kcOBM0n5lieAkpHVe3zwfLAh3qp4W8PlKNeVq0t6RnK8T0gHBiYZrh2dYbQy1wK1aswJAhQ5CXlweGYfD555/7zlVWVuK+++5DmzZtkJCQgLy8PNx44404cuQIL4/69euDYRje36xZs3SuCRFtaN1ZXNpSfkBbRRY4ga6cZYXrF/fPFlpyNrMXwiMQh0Fqxy2USigGHGDeDt1fLP97IDTRW603DjNajgF9X6hCvQTYbQxGdKqLxlmJwtdLaMNoetEIFw9Z4BRjqAJ37tw5tGvXDq+88krAubKyMmzatAkPPvggNm3ahE8//RS7du3C0KFDA9I++uijOHr0qO/vX//6lx7iExbCbG/Sytyh6rhQPSwruJDBuwdqapj7iroFGlu6BY7//YqL8rDm//oKpzWpshKKaNwLVU9oDpw2KI8Dx80jeCZzburICyfEC0ESunjLYagLddCgQRg0aJDguZSUFCxevJh37OWXX0anTp1w6NAh1K1bM0cnKSkJOTk5mspKWItw+3AtOosbO9fDu6sPAgCChEwTRcnLq1CH6fawgsqPV4EL9y15VGFdzPnlAO+YZAucX7I2tVOQlmDMRvVSCLb7Rc134Wut6kIVwqRiycIKddAar/LMnwMn/UFvkpUougqYYRhc074OZv+0F10apYclZ6QQUYsYiouLwTAMUlNTecdnzZqF9PR0FBQU4JlnnkFVVVXQfMrLy1FSUsL7I6IbJYF81Tb3PzK0le+zEgucMhdqIB6PsAXO60KVQjCFrHFWErY83J93TAvXiRmUFUVhRASPqaPNmcEqaYb74kPRS4/6YqiNkpBCYkjfSkv/hvGvR8PMRGx5uD/e5+wsY2UiZhHDhQsXcN9992HkyJFITq4JJXD77bfj4osvRlpaGlatWoXp06fj6NGjeP7550XzmjlzJh555BE9xCZMSrgDIsMwsNsYuFXcV4drmVGmwIXKX9oxt8gkOLG5Zlwua5OD7UdKMPXSpkHTJcfyo9lLnwMnvV0iYaANhtQni1yC5sPoR0/iom5VkeNC5QXyVTnEoX/fYmUiQoGrrKzEtddeC5ZlMXv2bN65adOm+T63bdsWTqcTEydOxMyZM+FyuQTzmz59Ou+6kpIS5OfnayM8YUkYADE2BhUa5a9kNZaSOXBCimK1C1VZ/hN6NMJF+amy5ZBqgYs0pUxKm/mnEFLIrKSjGW0F1GqBgZmeTf/fdTiiaV0tK2xjaBSmd6F6lbeDBw9i8eLFPOubEIWFhaiqqsKBAwdE07hcLiQnJ/P+iOhGyQAZbG/PcHHYbchJlhelXpEFTiBd9SIG/pkHBrcQzfejiZ0lSBccTVyohttBwrOOkWVNG8JtV+OfqtCEUlK1cKHKQSwOXDiYSYHWC1MrcF7lbffu3ViyZAnS00NPTNy8eTNsNhuysrJ0kJCIVMJexMAAMRpv+zIthBvSH7UC+bo9bMDxm7s3FM2jbZ2UmvxkS1CN9EUM/gsAxK8za4ceEEbE74DcR5P0POWY9RkJFyOqJcWyWRMih3MsaJ5hiWR5DHWhlpaWYs+ePb7v+/fvx+bNm5GWlobc3FxcffXV2LRpE77++mu43W4UFRUBANLS0uB0OrF69WqsXbsWvXv3RlJSElavXo2pU6fihhtuQK1atYyqFhGBKBkDNY9ZJCP7d8Z1wpsr9oXITtAxGnDEw8pb0apEcdQiD6vBG+QsrqRZrXpGP85qdk1qVsXrLuVaQa3+bGuJoRa4DRs2oKCgAAUFBQCq57MVFBRgxowZ+Ouvv/Dll1/izz//xEUXXYTc3Fzf36pVqwBUu0IXLFiAnj17olWrVnjiiScwdepUvPHGG0ZWi4gAwu0zGIaBQ+ZM4XYcS5WkMiSmu7KgNno2zZQcS41XhsglcuYJcYtVOnD1bJYpKZ2c7M2gEgq1Y98W1UGaa8WLTLb2WimiKIyInoQ7B07sejO1rdlfiLhrv2gOnHIMtcD16tUr6HyEUHMVLr74YqxZs0ZtsYgoRMm8GLku1Nt6N8bE9zZKSssw0jthbzKuIvXqqItx27xNgum4iOl83LSvXH9x0PK5ciqZd+a02zCiY+Deq6HkigSEnqubuzdAnVpxKGxQvVWTJNeTwnNq8cmkzhg+e7Vm+et5W6NhbqF/3+FfYy3mh8rJ0UMWOFUw9Rw4gjAzE3s2kpXe5bChRa70BTNSXbT2fzrrkZ2qlaD29WoJbhgvhFhHzj0eKlAuE6YFblCbHOmrUP3kDXaVWZW9GLsNQ9rlIUtkkQrLCbagNkoGy9qpcWhfL/S+oJGIkkfEpI8VD0M2s5cSRkRD63I0QgocEZX4v4WH6k+EOqcRHUOHnmnC2U/RbpP33ivVJep92x7QKgdLpvXA/FuEg1gKhwYRyzN4Gr7Spt9oIa8o44daK+yJaYEq6AL31230Cmjzu1C5FrhgXjg9pIlcSIEjCAkIdYgMw+DtsR2CXleLs2+onWEEA2wyDHBztwYCZUqUjZNn46wkuBzSd0wQnwPH+Sx03u9769rJyEpyoWl2kuSyvVi5k+YOTg4bgwGtsgPSBMaB4//3zydYGVoQrjLQTkFcQC2xglIdCv8qar1iHpD3uqRFGJFoJCIC+RKE2vj3GaE6EbHOqU/zwAGZS4yj5kqbjRF8M9/52MAApcvlsPlco6GQOiBJ2ZfTd5xrTRC7jtNoX07uBjfLIkZBbDyPjB5c1iIGk43Tvz86UNJAarbxLNx2nHdzIVo/9L06wqhA2HHgTPZcCeGvdMfF8Id6LeogZy4nzwKnvihRA1ngiKhkw4HTstIrtUJwt5+y2xjBjpOrvN3dvykurpuKER3rSnahSlX0hBC7MtS8Nv9DNhujSHkD5HXg/rIEq7rZxlmnwyY8yIkIKjVWltaEa4HTOtoOEYj/LYtzmmSo/+dB5ipwwV7gomHBSTiY5K4ShL68smyvrPRKxzB/pcZ/APffbWFKnyb49LauiHPaJStmUgfIBhkJAce48mQnV289l5XkUjWSe0hk9dGRpQ0ocdfJHbO0HuLCvdf+VmehsBFidWgo8MyqSbjuVJ6CYaJH01/pjndq72yTtwq15nOw5z07JfhuNNyXX7PP+9MCUuAIAkCwYfCuS5sqt8A5an5iVe7APUbniSw4AOTsDyot3ayr2gRey5Xl5ksw7KI8zL+lkL+IQahMFUcrOXGg5NwGM8x1UmJBqAl2ys1HJXkUqHvhtqKS2/DVlG64sqA2XgoRwkaZPNrEgeOnCauIsPHvOuJipM+L9UfqEyOrzqzgRwDALd1r5gOP69oAl7cVX1GfmeTCtEub4v5BzREbRh0jFVLgCCIEPZtlKu6QuS7U6j1Ga849d007NMpMFLiqGqllSlEu42LsgmEruPI0zkrEiyMK0DgriTdoC2av4gCllZfEePVNGgEWKt92Q+ZwH+lh2fAvoU2dFLxw3UWonRqnellquuXM8JIgRKAFzhzKjfeZ9gR5O+nZtGYbzNgYO56/9iLf90RXoCXx9r5NcKvMkE5WgRYxEASCKxHhWJu4VrQqD8vr8EP1/ZLjwIXxGiY2APHn3wksYlBeZAByxlP/cs05fNagzIUqT8HQeppQ2C5UKfHBwivCMLj3ykzPov9zFxeGAie9XtJTylnE4HTY8Mbo9qh0s0iNDx6TMtogBY4gNITbj3o8gS7UYKi5ClU0XIhYeoX5KUGeC1XGcGKCEVWKMia2mT3/UuNUnHAtcEbHRAuGeSULD/93v7Z1UhXnpYULVe4+v/1b5UjPPIogFypBIHgnpZYi4PawsgZDqatQw3IJSViGKrxwUsU5cGFY4IKnjczh2eOJVHuUMFIe+ci8U+bFv5/xX8BklOvX+1unvVDVgRQ4gtAY76blBXVTeSNVqD5Un7lHIi7UUIsYVLXASccMVjWtEbLABVNytR4Aw7fA8aHIENqj5u9Ealay1jDQXqiqQC5UgkDoTiScTmb19L4oq3AjLcEpKyYWd27b5W1z8fWWo6rLJhaDKWQgX+VFBhCWATHISGUGZU+Se9vvu9kMcEK7hxCBmGlBgxEhNeQUSYF81UGRAnfu3DnMmjULS5cuxfHjx+HxeHjn9+3bp4pwBGEFYmPsviXucvZL5HbCdWrFi6YLpwOsdHsEj4eywKmJHBewicZISSgKI/LPNVpY1pQoy5HqipZCuM+TWZWPUPUy6o76dmLgdDv+zyS5VKWjSIG7+eabsXz5cowePRq5ubmmevMgCCUcP3sh6Hm1HnE5+XBXoYaz0jQYVW4RC5wJ3LtCWFGZCHeVphylTM62ZV7C3UkhGscHo6ts9qC26Yk1q0lJYVOOIgXu22+/xTfffIOuXbuqLQ9BGMKGA3+LnvPb9jMsZC1iYLgKXHganFipYha4kOFODJoDJ6dcM4xhSpQXr5KlxdwgRXn+U4cBrbLx/fZj6gpkAGoqlMGD7RiHEduXSXm58lqXn7yyDbo/veyfg1pKZW0UjQq1atVCWlqa2rIQhGEosUwoIdQeo1y4CpwjSI8sRfTWtVMEj1eJTLjiD0yBZbetkxJSLqnIcqHKyNcMlh9lLlRpx5SgJBvvLb7hknqKypRyF/Qcw9UM5GtW3cPsFrj8tJopIWZtw0hAkQL32GOPYcaMGSgrK1NbHoIwhFAKnBH9Id+FWvN5TOd6eHhIS993KS6I/44sEDxe5VFmgXvh2oswpnM9LLqje8iyQxHOpH2Tj1OS8FeQF20VXqyiBkpClKTGxWggiTmwokseQEitWYvfjdI8acN65ShyoT733HPYu3cvsrOzUb9+fcTE8H/gmzZtUkU4gtCLYOOamp28nDdj7rw3rqWrV7Ms9G6ehYe/+l1yXtkC22gBQGWVcMVDGdaykmPxyBWtJZcfDHlhRLSIC28ufvuzGBcq3Zq4UJVYmjMSXWGVGY1x4IxWDG0MA7fOipHSuZz+YmqxfZpVUaTADRs2TGUxCMJY9HoLlPOWyp8DF2JOmkJEw4joOP5o50KVL4vaKHXjllfxLaNqTfRWYu1M/0eBM1opUQutXOtmeN682BjArXOZ0ubABR7zfyYbZibi9dHtw35xiAZkK3BVVVVgGAbjxo1DnTp1tJCJIHRHxJMIQN2OWekiBgdPgePnIab/XNuhDj7a8CfGdqkvWoaYAmcL4UI1CjPJIgUlW2lVXyhdaZPz7qHkRSXFYi5Uq7nshJ6f6t+vOvXUurWEnvMBtHWWJGTPgXM4HHjmmWdQVVWlhTwEYQi6LWLgfg6hjYjNgZO6buCJK9vgk0md8cDgFqJpRKKI8NDa8iJvKy3G77v0tJGMkYsYYuzV7ahUeTbDYhIxTCyaJLo3ycDGBy4NOB6qzTX5bSieA6euGNGEokUMffr0wfLly9WWhSAMQ6/o97JcqDwFruanKtWKF2O3oX29NDiCBJETs0boaYFTyz3ovyLWDIOzkp0YgOo2kTqwyWm/rCT5bim7ETEpIhAjXhha5CYjLcEZcFzNW0Z337womgM3aNAg3H///di6dSvat2+PhAT+RrlDhw5VRTiC0ItgFjhV9xWU5UKt+ezQaA6cWyyMiK5z4KSnDSaXw86IhkUxCqXuOv9qqFUru40Jui2bEGqEijETelgEjX55MKJ8pUVazaWtJ4oUuNtuuw0A8PzzzwecYxgGbrfe0ycJIjwMcaGGSMsVie9C9Z8Dp1x2MX2Hvxeq4uwlIc+FKk6M3YYLlR5Jac2O26NNfHqWBVwOu6xrvNbfSG5PLqrGgTOp7hHKSq9NGBFlmZq0CSMCRS5Uj8cj+kfKGxGJmDGMCFckhz2IAheGPOIu1JrPms+Bk1MDf1E4bdEwIyF4WgOQNKgJpGFZVrKiIWsRg3BxQVF7GzclsegIeUTSCk6zKsGRgEY7LBJEZBHKAqdWJyNn8JSiXIWLFBeq1hY4OeN5MGXy5esvVkEac+Afw8tIN5Nv/qVKz8HZcmsugDPabcrl5u4NdC9TsQuVbHCKUeRCffTRR4OenzFjhiJhCMIwDFjEEKrDT3DW/DxjOGYQNefwiAX75O3EoFppIqjU9vlp8Xjyyjb4v8+2AjDHKlRJYUQEjnlYbR5JJXqg2nPgTpaWBxyz2hBupDJ3WZscxDsVDe1hoXwnBnXliCYU3eXPPvuM972yshL79++Hw+FAo0aNSIEjIo5QixjU6pDlKF+1Epx45uq2cDpscDm4q1D56cLpAMXcWcarPsLIuQ9msojIRY6bUd7tl/+w2FRW4E6VVqiaHyEfM/00SH9TjiIF7tdffw04VlJSgrFjx+LKK68MWyiC0BvdXKgy01/TIR8A8OPOY75jgXPg1F/EYNYwIgFT4Py/m2lkgnJrqYeVHkZEa7wWOLUsmt2bZAQcM9ltU4QV6hAOylehqipGVKHaHLjk5GQ88sgjePDBB9XKkiB0I/giBvXgKUYKc5azEMKfn+/tjTdGt/d9l7aVlokC+YaoOzcvMwyoSndi0GqefzBxZlzeUvC4mnHghl9cB2OC7AyiN2ZT+PVCi8dL+dQO0uCUouoihuLiYhQXF6uZJUHoQqiBVj0XqsLrgoT1kKMA5afFoz9nmxoxV50eFjivJeZGGQO6PBdq5I7O1YtLau5NsHssd4GDWKsU1E0VPG5XsR0Ht83hzee0KmaYfxkpkAVOOYpcqP/9739531mWxdGjR/Hee+9h0KBBqghGEHoS1ALHaONCVTouhmOB80e03jqMP2+P7YhDp8vQKDNRtTzNprNJ24lBOIyIFijJ1a5wK6010/siLkZezDkiclH609MrBqcVUaTAvfDCC7zvNpsNmZmZGDNmDKZPn66KYAShJ3p1IoqVL85lNj8DRjiSi7pQRT6rSYzdJlt5kzPnzWS6nCzcfnPg1Aq1wLLiOYkpm0pXoeakxAaWEdF3JRBea1qravKRWf+xXerjvTUHMalXY23kiQIUKXD79+9XWw6CMJRQc45Us+yokI+6FjgpLlTzjEyRtgpV8VZaHumKudwShGL/JcWKDwVeF6oqzWmCe8LFagqlFmj1avvw0Fb49+AWUeFS1wpFLTdu3DicPXs24Pi5c+cwbtw4yfmsWLECQ4YMQV5eHhiGweeff847z7IsZsyYgdzcXMTFxaFfv37YvXs3L83p06cxatQoJCcnIzU1FePHj0dpaamSahEWQ87gGTwto6ILNfz4amqGEZEUyFd59hpgLmnUQHgRg3YWYaF7/v74QtH0emxmbzUnmhleHiIBUt7CQ1HrvfPOOzh//nzA8fPnz+Pdd9+VnM+5c+fQrl07vPLKK4Lnn376afz3v//Fa6+9hrVr1yIhIQEDBgzAhQsXfGlGjRqF7du3Y/Hixfj666+xYsUKTJgwQX6liKhGTJFRG6VjIX/uHD+TXAFXlVTMEEZEDrIscCZQ9tQKI6KWPsdC+Flvl58qeg13G7dwMf6OaGdRNsPzpgVSa2XV+psZWS7UkpIS3x59Z8+eRWxszcDhdruxaNEiZGVlSc5v0KBBooseWJbFiy++iAceeABXXHEFAODdd99FdnY2Pv/8c4wYMQI7duzAd999h/Xr16NDhw4AgJdeegmXXXYZnn32WeTl5cmpHmEx5Ax6+gXyDT8Pr3L19tgO+H7bMdzSvaHivKTMgYtYTFAJpS5UOS8UcouQ+7Lifd7UUHzE8tDzVhm5LZlZ0KIJzPSiFy3IUuBSU1PBMAwYhkHTpk0DzjMMg0ceeUQVwfbv34+ioiL069fPdywlJQWFhYVYvXo1RowYgdWrVyM1NdWnvAFAv379YLPZsHbtWtGgwuXl5Sgvr9nOpaSkRBWZCXMhp48K1aGp1eEptWxxBz6vFa9P82z0aZ4dljyiOzGoEK9OC8wjiXqIbqXFeehUs8CxQJVMBc7hv2omDMx2/0jpICIZWQrcsmXLwLIs+vTpg08++QRpaWm+c06nE/Xq1VPN6lVUVAQAyM7mD1DZ2dm+c0VFRQEWP4fDgbS0NF8aIWbOnKmaoklYg7X7T+tSjpoWODUQG8v13MxeDnKsQGaQW6nV6uCpc3h52R6Vpal+qZE7v847B84M7Umogxb3kh4P/ZGlwPXs2RNAtXWsbt26plqdJofp06dj2rRpvu8lJSXIz883UCJCC9Rylaj7lCsL0KFG/DguvZtlYtmuExhVWDdkeWYilFxmk1vpTgzTPvqNn0/QQuTJ4/ZITw+ou4jBDEOGZnPgTLvwJxByoVoDRbbxevXqYeXKlbjhhhvQpUsX/PXXXwCA9957DytXrlRFsJyc6mjxx44d4x0/duyY71xOTg6OHz/OO19VVYXTp0/70gjhcrmQnJzM+yOshxlnuqgxFqphgXtl1MV4Z1wn3DuwuXAZOqw8VEKoqnPvuTlrYDxy58CpqsCZ4K6oOQeOptMRRqJIgfvkk08wYMAAxMXFYdOmTb75ZMXFxXjyySdVEaxBgwbIycnB0qVLfcdKSkqwdu1adO7cGQDQuXNnnDlzBhs3bvSl+fHHH+HxeFBYKL4sniDkoOYbu+I4vtxAvirIE+90oGfTTDgdwl2A2hY/I4hUD4GWeFhWwSKG6v9WbE0r1skozKCcRxuKFLjHH38cr732Gt58803ExMT4jnft2hWbNm2SnE9paSk2b96MzZs3A6h2zW7evBmHDh0CwzC488478fjjj+PLL7/E1q1bceONNyIvLw/Dhg0DALRo0QIDBw7ELbfcgnXr1uGXX37BlClTMGLECFqBSpjy7ViN8Bx6GMd4ixhMpAj5DxL+99g8klYjaSstCWmCWY3k7NLAstW7PMjBai5UNYkkt6nWWO3eRgKKdmLYtWsXevToEXA8JSUFZ86ckZzPhg0b0Lt3b99377y0MWPGYO7cubj33ntx7tw5TJgwAWfOnEG3bt3w3Xff8cKXzJs3D1OmTEHfvn1hs9kwfPjwgL1aiehEre2H1ERpH8ffzF77ntKsA1OkuVDNFrLCw7KiK4/FkGLxbZqdiD+OhQ6gboZ7oiZit5eUGUIPFClwOTk52LNnD+rXr887vnLlSjRsKD0mVa9evYJ2cAzD4NFHH8Wjjz4qmiYtLQ3z58+XXCZByIWBmnHgws9IDwucWQP5yiFS5RZCLTXQoyCMiE3CKtSUuBjxkxxcMRR5P9Iw1ysIwUWRAnfLLbfgjjvuwNtvvw2GYXDkyBGsXr0ad911F2bMmKG2jAShCDWNH6ptpaXQssW1JqoZRkQMs+o+oapuNrn1sJbKeTZZlpUdRkTKC0Oo+U+3922CQ6fO4eK6tWSVTUQOVnphihQUKXD3338/PB4P+vbti7KyMvTo0QMulwv33HMPbr75ZrVlJAhDUbNjUjrRl2s00UWB4ymakdkzm0Fu87lQgSq3UhdqkPYM0dTTLg0M/G4G1F2gZPzzJhU500uUBTsi9ECRPZthGPz73//G6dOnsW3bNqxZswYnTpxASkoKGjRooLaMBGE4avXNXGuGnA6fqwgwOnihzOpCDVjEECytieQOhiQ5VdIDPQoscFLki5Cm1hFqEUJ7ZA0F5eXlmD59Ojp06ICuXbti0aJFaNmyJbZv345mzZrhP//5D6ZOnaqVrAQhC7O7UJWWr4cFjouZhqJIUcr0RO6WcbLjwElaSSsrS8tgLvuqsUTrM2AkslyoM2bMwOuvv45+/fph1apVuOaaa3DTTTdhzZo1eO6553DNNdfAbrdrJStByEKtVahquuKUuln4c+DUkkYcvZVEqfiLZU4pa5AURkRCLdR6lllFceBCL2Iwg7vaaEz6k9GNKK++IciywC1cuBDvvvsuPv74Y/zwww9wu92oqqrCb7/9hhEjRpDyRlgW9Vahcj7LuM7D2f5I7zlwZuqZI82FasY5cKM715N1jZTnzQxtrYRwxY7QahMWQZYC9+eff6J9+/YAgNatW8PlcmHq1KkRNXmTiB7UdHuqlpfCLp8X30zvMCI0TJkaOUoiCxZjOteXlb+UOZfROgSItbzZ24P2QrUGshQ4t9sNp9Pp++5wOJCYmKi6UAShBuayfVSjtJPjTjzXfRWqiTrmAFmCxZE0geIpbSeG0PmwLFBR5UGV3J3o/fB4quO6pSc4Qyf+B+8cuGBimqGtpUIGB22IpGfAKsiaA8eyLMaOHQuXywUAuHDhAm699VYkJCTw0n366afqSUgQJkCbVajSr2P1VuBEPhuNHFnMME6r5UKtcHvQ/rHFSE904qd7eoe+QATvi0CMXfq7u9VcqFq5tSOoCQiLIEuBGzNmDO/7DTfcoKowBKEmf/5dpko+lW6P8S5U3ipUdWQJhlkHZLPKFQ5SqrTneCnOllfhbHlVwDm5q1AB4LXR7THslV8kyeFtcytarixYJcPgtmV+WhyOl5SjvCo8izERHFkK3Jw5c7SSgyBUpeRCJQa++LMqeVXKDHwaDKXKF3fhoD4DKTcOnJlGucgKK6pW23EVeJZlFefrtcBdlJ+Kh4e0xMNf/R7yGikWOLOuWiaMYfndvXHDW2uxau8po0WxNLQxHWFJ/vr7vCr5xMXY0TRbxXmeCgPkqhVGQgmROjSbS/EMD+4cyHCswUoulbSVVgQ1tVbPhdIV5lYhGutsNKTAEZZErT76sWGt1d1uR+F1MkN3hU3ELGIwOVLmW0laxCDyuboM6fJwFcG66fGiZXCxezezD5JvJN0Ws4V2sQpWemGKFBTthUoQZsesLh2l4Tn0HnTM2XoyFzFoJoX+cG+/h2VhV2EuZe9mWfi/y5qjdV5K0GukraSNzNaOVLnDRda8SQX5R2mz6g4pcIQlMWv/ocZWWnrAKFQ0tcZ/wDV7IF/15sCp5ELl7qnLMJjQo5FgupS4GBSfr+QdC74TQ3RCxjzCSMiFSlgSLd+sf7q7l+JrlS5iMHIOnJlG51CimEFp4yLJhSplKy0/CxzvnIxnQytXvNna3RjMuvAnEC0s2SavsiUhBY6wJFqG2qifkRA6kQiMwpnOulvguJ8jqGPmtpPZB1E5+CtpSl3q/sofl/BayzptHQ1o3Z1Y6bdnZkiBIyyJWh2IWbohI101ZmkDILKUSUD+TgyPXdFKMA3Xcvbg59vQ57nlOOeNCSfj2ZD6HAmJHcxSGGn3hVAfM021iBZIgSMsyYVKt9EiCKJ0cUUwy4kWmHVADjVImFVuqTTOShI8zr39Czf+if0nz+HL347Izl+r5yjCm10VIv3ZC5dor78RkAJHWI4qtweD/qNOEF+1URorSm8DHGPS+Tz+ovjrI2abVC7X1el0CHfJas2BDCaOw678PpvoETEF1ByEHpACR1iOM36r58JB7YFJ8SIGAzUTGoz0Iycl1hd3jYfA7T9VWi52ise4rg18n4NZ4FrmJmNQ6xyM7VJf8HzwVaj0lEQ79AToDylwBKEjSi1b+ocREf5sNvxlM5uscq2XNgZ4a0yHgONCitezP/wRMr+r29fBjCEtOfmIp2UYBrNvaI+Hh7aSPRibrd0J/aFnQH8oDhxBhMlrN1yMX/acwtHi81iy43jQtGIuslDovRODWQnlQjUb0nZi4Mfcc9oDnxGxXE6fqwia9wODW0jMSVwmaellJbck1ASE3pAFjrAcag7qUgamga1z8diw1sKuLz9iY5T95PSOA2fWAdlM8/G0QkjJF3umP954WPTck1e2QWq8k3dMszhwUau+CDeo2R9T2k7MGpACRxA6Ehtj932W08eTBa4ak4+LASixZAkqcCLpK6o8QfPyR+oqVCGpg1Yl0m4MoTrR8HJlNkiBIyyHUbsWSLFCuBz2kGmEMPKN2Uwv61YcIxi/z0IKnJji5RbX3wQXzHjCeBMIGgcOQI+mmYrztgLRrsBEd+2NgRQ4gtARxS5UA/dCNZH+FnEoUbyF5sCJKV4elhV9YRFSuLR6jhiGwSvXF2iTOUEQgpACRxAqIeUFnGuBk/PC3q9lNgCgUabybbzkkJno8n2Oi1FmNdQCf6XECnN5GD8TnJAFzh1EgRPPWGZ6MZmCHOMWFe+kNXFRDZngdId+cYT1UHMRg8q9klILXO3UOPz64KVIjNXnJ+t02LD9kQFgGEhanKEXkealkj0HTmQVqpjiFUwhE9r1Qyt1l2EiZ/zWw9UZjYs6orHORkMKHEHoCHcRQy2/FYKhqJUgL324JLjM1z1E2hChyIUqwwLn9oi7RYXaKpyttEJZ4CJFudbKahsh1ScsBLlQCUIlpAxg3DSNsxK1E8aqWHCU5HlQRVyoYmsPgikjQs+jdN0l8OLgm9kzYVm2MpNcoRMRpiZSFHgrQQocYTnUfL9Wu1NqmpWEKy7Kwx19m/CscYQ1ke9CFVnEIKJ5lVd58P32IsFzgi5UFX8cLXOTg5Ylh6evbovuTTIw96aO4YqlKxaYgqkapL/pj/l8JAQRoUiZA2KzMfjPCFqtp5SARQwhzkciDgEFTsyFOnfVAdF8uDpVSlwMis9Xol1+imK5uPn9d2QBGmcm4rL//gwAcIQ5T7JOrXi8N74wrDyMJlK2n1ODBhkJ2H/ynNFiRD2kwBEEETFE2sAoZb4VN4WYxU5MgZPK55O74v01BzGhR0NJ6Suq3AHH/OPVcRe32Ey00EVPIu15VIt3x3XCnF8OICvZhVnf7jRanKjF9C7U+vXr++ZXcP8mT54MAOjVq1fAuVtvvdVgqQkjIbeGdbH6eClWPyWLD7huzQYZCXjw8pbITo6VdG15kB0evHANheFa4CKVaO1r8tPiMWNIS9SpFec7Fq3KrJGY3gK3fv16uN01b4Pbtm3DpZdeimuuucZ37JZbbsGjjz7q+x4fH6+rjAQBwPrahQmItGj3asmrxAAXTtFCCpx/flwF0UyhZghjsML0hUjD9ApcZiZ/e5ZZs2ahUaNG6Nmzp+9YfHw8cnJy9BaNMClqbqVVkF9LtbyI6EOSC5WTREzpUuJC1XJA9Y8PSAqcdRWYga1z8c7qg8hODlwpbNU6Rwqmd6FyqaiowPvvv49x48bx3mznzZuHjIwMtG7dGtOnT0dZWVnQfMrLy1FSUsL7I6yDWm6NpXf1RN10suaaCasPF2IDohIXqvrGSn6GXAuc14XaoR698FiNzo3S8d2d3bH0rl5B00WYcdwSmN4Cx+Xzzz/HmTNnMHbsWN+x66+/HvXq1UNeXh62bNmC++67D7t27cKnn34qms/MmTPxyCOP6CAxYQRq2d8aZcqL00b9l/ZE2iCh1IXaKi8Z24/UvFgqs8CpS4ALVcACl5FI8dwiAbnvA81zkgWP81behiEPoYyIUuDeeustDBo0CHl5eb5jEyZM8H1u06YNcnNz0bdvX+zduxeNGjUSzGf69OmYNm2a73tJSQny8/O1E5zQFSvsj0kIE7gXqkGCaMU/1Xt7bEcUPrnUd1jZHLjwh1QxzygDBnYBC1w0E2kvF2pAt91YIsaFevDgQSxZsgQ333xz0HSFhdWxhPbs2SOaxuVyITk5mfdHWAejBvVIm2AfkVi8ib2PkH9g3B1HSwTT+XNL9wYh00jhnXGd0CAjAR9O7FyTn18am437mQm7TCth9nZQSz7ec2r2SluQiFHg5syZg6ysLAwePDhous2bNwMAcnNzdZCKIAgiPITeN0ItChCyeMXG2PDvwS1938MZTns2zcSyu3uhY/20mvz8BmjeKtR/PuekSAtTQhiLWi+54e7AQYRHRLhQPR4P5syZgzFjxsDhqBF57969mD9/Pi677DKkp6djy5YtmDp1Knr06IG2bdsaKDFhJJZzqxE+rD5eeKsXyjVVPXDyH3R/97LWFmHunq1eF++d/ZriZGkFhl2UJ3KVtYj2voZrhbX4T9OURIQCt2TJEhw6dAjjxo3jHXc6nViyZAlefPFFnDt3Dvn5+Rg+fDgeeOABgyQlzICaYUTkQB2Y9kRaG8udj+lVukIpX1LCdqg9P4m3EwPD37PV/U89U+Ji8NJI2iouWuA+p1Z/uTIjEaHA9e/fX7AjzM/Px/Llyw2QiDAz0f5WbGX8FRur3upQCppdwmip9YDq4ljg3J7QOzdYkWhXWsiFaiwRMweOIKRi1KBOfZn2RFoTS3Fjcl9OJbtQBRL4F6V2kNWA/DkHqsLcqzVSEXtZjJYFTdzHkIL66g8pcITloDAi0YPVhgyxVaj+SHGPqq1DcAdo/6zdbvrNRZLOptY0Exu5UA2FFDjCcsjpmhpmJmgmB6E+/oNEwL22yCASWoGT4kLVrzGi1QIX7ZDSZiykwBGWQ44BTspcIqlQX6Y9Id00Ea5HeOunyIUa4nu4BPupKNnqi4h8eBY4A+WIVkiBIyyI9MFEq0m4uSmxiHfaMaV3E03yj1YCLHAWUxy89VMSB86/JfScYE4WOD7Rosxwn1OyxulPRKxCJQg5yLLAqRhrgeuymn5ZCwxuk6tq/oQETNbcShXMUO5PIeWsym8empYDqn/enihV4LhzyaJxEj91b8ZCFjjCcsgZSrRSsBgN8yZqCFB0IlCPUKLj2QR67iq/UB56ulDJAhed8OPAUX+nN6TAEZZDzoAoNJcI4Me4UgL1ZdoQaS5UuYOa1ORCczf9dSg9B9S81DjdyjIT0Wh140Jx4IyFXKiE5ZCzRN5ff5vYoyGKz1fipq4NhC8IAi9SfZR37FoRsl2jpNmlrUJVt0y+Qlj9+f3xhfh221Hc2rOhuoVFCDwXagTt667eXqjq5EMogxQ4wnKEswp16EV5aJWXErYMZu/AIxUrtquSeVRilmMuqrtQBY51a5KBbk0yVC6JkErL3GRDy6c4cMZCLlTCcoTjQg3LJcAIfiRUxOrtGo4LNTAvq7cWMbRdnqLr1Ho0eFZHy/86zQcpcITlkONC9R8IaU5HZFOQn2q0CLoQ67SHTKP6ZvYR5CKMFqRYYoVQz4Uqr/xhFylTOAlhyIVKWA55Fjj+d7tKrzQ0wGlDKKtSk+wkfDmlK7KSYnWSKDhyF1lIfWwaZybit8Nnguel4VZaRCDRaI2SutK+Z9NMTOzZEO3r1dJYouiCFDgiqrH7aXDhuJ0Yv2UMhPpIadW2dVK1FkMzpD5/uSniCmpKXAyKz1eieY6x86MI62OTaJWNsdvQpRHNlVQbcqESlkPeIgb+d7VcqGSB04ZIa1cpCpmyOHAMZo+6WPDcun/3xdaH+yPBpe77eaS1PaE9vDhwBsoRrZACR1gOWXPgAhYxKC+X70IhtMDqE/Ol1u6mLvURGyM8D87lsCMpNkY9oQSw9l1Qhtndpu+PL/R9NmoOHKEupMARlkNO5+SvEIh1SLmpoedU8d0J1LHpgcnj+MpGymMzpF0eaiU4tRfGD3qiA4mk50+LcC9SXaiENpACR1gOOX2qv8VNbFXXG6M7oHuTDCy8tbNoXtw3cOrLiHCZcXlLweMx3mdU74eMHmrJmF2ZUUs+Xhw4ekB0hxYxEJZDzso/h98iBjEXauOsRLzHcUEIwc3K7B24VbBCO3OfVq7ldly3BqhdKw4T39vIS984O7E6rR7CiUAW5shGLcshPQbGQhY4wnLIssCpGciX3kB1x+wurHD3ao3xW2VzactsjO9Wvc2b3koUWViCE43KDM2BMxZS4AjLIWfM7NQgjfc9nP6I5oMQauNvIf6/y1rA5QgdxFcL6Jkm/KGttIyFFDjCgkjX4Ia2y8OU3o1936VsUSRGNAbyJIITbhgRh5+F2E5hGyKCaLk3/oHQCX2h5icshxwLnMPG4LqO+b7v4bgEbBRHhFAZ/zA3drtxFg8KUx2caGwTelE1FlLgCMshZ9aR3cYgkRPwtNLtUVwuDXCE2jj89nazm2TVn8mnHhIhUOv+qb3fLiEPWoVKWIoqtwfnK9yS0zNM9dZD+Wlx8HiA9ESX4rJ5UclpQoguyAnabFaC1cHfhWrkgEnPNOEP1+tg9gVFVoQUOMJSDHhxBfaeOCc5vZ1hYLMxWHZXL3hY6ZszC0EeVEJtHP57vRm4UIae6UBEdZYoaSzuM+ghDU53SIEjLIUc5Q2oUdj8XVVKoBVZhNr4r0I1S7DocMOjWJFo/M1zrbL0ROgPzYEjoho13UJR2H8TKhB0FaqfBc7JfdHQ2wJHDzjhB9dhQTq9/pACR8hmZ1EJvtj8F72F+8ENCkyrswg14M6BczpsSInXdpP6YNAzTfjDfQEmF6r+kAuVkM3AF38GAKTGO9GzaabB0pgHxsD5SdGK1ccMrmt/ar+mvHO0CtW8RIuyy7fA0VOhN2SBIxTz+5ESo0UwFWaZn0RYB64Fzn99je4vCfRQhyByGkgtZcvGs8CpkiUhA1LgCEIleANs5PTlhInhror2V9joESOMJoZjIU5LcBooSXRCLlQiaimom6pqfrSVFqE2MZxVqEZbOBiasG4Z1Fq8Zbcx+PaO7qio8uDg6TJV8iSkQxY4ImpplJmoan4URoRQG+7WWf6TxPUOrEuPdCDcW6LH7ZjYo6Eq+ag5X61FbjLa5aeqlh8hHVLgCEIlaIAj1IY7B85/zKWXBPOi1b25rE2uNhmrAD2O+mNqBe7hhx8GwzC8v+bNm/vOX7hwAZMnT0Z6ejoSExMxfPhwHDt2zECJiUhCbTcQbystdbMmohSuAuf286HqvoaBp5WQDxUwRonOTYnVv1DClJhagQOAVq1a4ejRo76/lStX+s5NnToVX331FRYuXIjly5fjyJEjuOqqqwyUlohm+GFESIXTAyuoEcHcWdxFDOFs86YG9EQHQnMBCSMx/SIGh8OBnJycgOPFxcV46623MH/+fPTp0wcAMGfOHLRo0QJr1qzBJZdcoreoRJRDc+AItWEYBjd1rY8NB/7GkLZ5fucMEgqkuBCEGTC9Ard7927k5eUhNjYWnTt3xsyZM1G3bl1s3LgRlZWV6Nevny9t8+bNUbduXaxevTqoAldeXo7y8nLf95ISimcWjbAq228oigihBQ8NaSVyRudFDPRQSyYam4qeD/0xtQu1sLAQc+fOxXfffYfZs2dj//796N69O86ePYuioiI4nU6kpqbyrsnOzkZRUVHQfGfOnImUlBTfX35+voa1IKIFW5CYXQQhhlJrlt7PGIXGIQhzYWoL3KBBg3yf27Zti8LCQtSrVw8fffQR4uLiFOc7ffp0TJs2zfe9pKSElLhoRFM3EA12hHUhD2ogkfSL1+P+FTZIx6q9p3QoKXoxtQXOn9TUVDRt2hR79uxBTk4OKioqcObMGV6aY8eOCc6Z4+JyuZCcnMz7I4hwoTlw+hPNc7H0X4Wqc4ERAHcaRhQ/igACLbS39lInZh0hTkQpcKWlpdi7dy9yc3PRvn17xMTEYOnSpb7zu3btwqFDh9C5c2cDpSSMwujNlGmAI5Sg9Kmllc7mJRrvTevafEOIy2E3SJLowdQu1LvvvhtDhgxBvXr1cOTIETz00EOw2+0YOXIkUlJSMH78eEybNg1paWlITk7Gv/71L3Tu3JlWoEYpcvU3tdU9bpSH6Ou+jSEKx0kfRlY9mi2fXGheYA310hOw6PbutCeqjphagfvzzz8xcuRInDp1CpmZmejWrRvWrFmDzMxMAMALL7wAm82G4cOHo7y8HAMGDMCrr75qsNSEURg9pvBdqNSx64HZFYl/D26B2+ZtwvhuDYwWJWzokQ6E60Kl5gFa5tF0JD0xtQK3YMGCoOdjY2Pxyiuv4JVXXtFJIsLMyHWh2jQckagzJ4DqrY9+ffBSpMbHiKaJlFWoRHBM/i5BWJCImgNHEMGQ2oEOap2DOrXicPeApqqWT4sY9EftWH5aUCvBqYlFVm/3Hbe8SGh3I6GfP6EHprbAEYQcpFoyJvZshIvyU1Uvn7eVFnXhhMboHgeOHumgUPMQekMWOMIyGG0VIAuc/pCiTBAKIAOqJSAFjrAMRk9oJ6VNf4xW2qMJerwJwlyQAkcQKkErTwklKFVCaTN7gohuSIEjLIPRgwpvM3vS5QiN0X0RAz3UkqGmIvSAFDjCMhjtTuPNgSOHE2Ex6IkWgCyRhIGQAkdYBsMtcIzwZ4LQAkNdqMYVTRDEP5ACR1gGqYOKVuOejRQ43TFaaTcSI8OIGL3vMEEQpMARFsLoQYXrNiUXKiEVxTsx0Bw402L237/R000IdSAFjrAMRndJ5EIl9ISeMYKIbkiBIyyDVEuGVooew1vEQBAEYU7MbiEkpEEKHEGohI36REJH6HEjlEIuVGtAChxhHST2SVoNfORCJZSgdCilZ8zE0L0hdIAUOMIySH2rTEtwalK+jTeiUg9OaA09Y4Qy8tPijRaBUAGH0QIQhFpInQOnVefF0Gb2BBFVcLucSFilu2DCJdh97Cy6NMowWhRCBUiBIyyDFP2tUWaCZuWT/Y1QhMI4IrQXqrkwOoyRFC5pmI5LGqYbLQahEuRCJSyDlA5Uyy6Wt5VWBLyNE5ENPWHmhX7+hB6QAkdYBknKmYYaHG8Rg3bFEAQAY18SaBUjQRgPKXCEZZDiwdDWAlfzmd7ACamQKmQNyOpO6A0pcIRlkGIV8Gg6T4U6cL2JhHlHWkFPG0FEN6TAEdZBigVOw/GeZ4Gj4ZXQGFrEQBDRDSlwhGWQMqZoOXcnxl7zcyJvCiGVSNnMnpAO3RlCD0iBI2RhZpeV0aI5HfRzIohowoz9Yb107UIlEeaC4sARsjBhf+VDinVNS/ldDrLAEfpBLlSCy4cTLsG324rwrz6NjRaF0AlS4AhZmLnflrQKVcMKOHkKHGlwekCKBGEkZvqdFzZMRyEF6Y0qyOdDWAZJc+A0HPFdDrvvs3m6dcKqmEh3iFrE+hMzKXaEdSEFjpCFGed8eDF6JwaaA0cogYLiElalQUb1fLwh7XINlsSakAuVkIWZhxpzuVC1K4cgAKN3YiCI0Hw5pSt2Hy9FQX6q0aJYEjIZELIwsQFOElpaO1xkgSN0hN4RopMZl7cEAEzs2dBgSUKTFBuDi+vWIpeyRpAFjpCFmd09RiuXXAtcldu87URYAxoTzYuWt2ZQm1z89lB/pMTFaFgKEQmQyYCQhdFKUjDMFEakwu3RriDCUpj5NyWGmefC6olRrUDKGwGQAkdYCCljikfLOXCcnRhsZB7RhWhWI2gnBoKIbsiFSsjCzC/e0kTTrgIMw2Bqv6Y4da7ct/qKILSC3hGMh24BYSSmtsDNnDkTHTt2RFJSErKysjBs2DDs2rWLl6ZXr15gGIb3d+uttxoksfUx9xw4Y12oAHBHvyZ49IrW2hZCWAqlj6SRyoN5ewF9EWsHUq4JPTC1Ard8+XJMnjwZa9asweLFi1FZWYn+/fvj3LlzvHS33HILjh496vt7+umnDZLY+kS6Bc7E4hMEQRCEZEztQv3uu+943+fOnYusrCxs3LgRPXr08B2Pj49HTk6O3uJFJWZWgKTFgTNzDQhCBmTlMRV0Owi9MbUFzp/i4mIAQFpaGu/4vHnzkJGRgdatW2P69OkoKysLmk95eTlKSkp4f4Q0zK0AGbsTA6E/pn4cJaK0DoYuYrBAuxNEpGNqCxwXj8eDO++8E127dkXr1jVzjK6//nrUq1cPeXl52LJlC+677z7s2rULn376qWheM2fOxCOPPKKH2JbDzP220TsxEISe0Dwrc0FdC6E3EaPATZ48Gdu2bcPKlSt5xydMmOD73KZNG+Tm5qJv377Yu3cvGjVqJJjX9OnTMW3aNN/3kpIS5OfnayO4xTCzAmT0ZvYEQRAAhXgh9CEiXKhTpkzB119/jWXLlqFOnTpB0xYWFgIA9uzZI5rG5XIhOTmZ90dIxMT6jyQLnPZiEBpzfWFdo0VQFaUru41dhRrdv6QxnesBAKb0buw7RioboTemVuBYlsWUKVPw2Wef4ccff0SDBg1CXrN582YAQG5ursbSRSeR3nEnx1IE80jnySvbGC2CKaD9JY3jkSta44/HB6FJdpLRohBRjKldqJMnT8b8+fPxxRdfICkpCUVFRQCAlJQUxMXFYe/evZg/fz4uu+wypKenY8uWLZg6dSp69OiBtm3bGiy9NTGzB1KKcvnGje11kITQi0h/oQgHQy1w0dvsPrh7HxOEEZhagZs9ezaA6mC9XObMmYOxY8fC6XRiyZIlePHFF3Hu3Dnk5+dj+PDheOCBBwyQNjowc78tNqgcmDVYX0EIQgZZSbFGi0CoDBlHCT0wtQIXasJ5fn4+li9frpM0BGDuRQAmFo3QCCtMFr/hkrr4o+gsejfPlHUdKQkEEd2YWoEjzAfL+2wujcls8hDaY4V77nLY8dTV8qd8GKm8Rn6rE0TkQ058QhZcK5fZLF5mk4cgCIIgtIIUOEIWVrB4EARBEESkQwocIQ+eBc5cypzJxCEIy0K/NYIwHlLgCFnw5sCZrBMn6yARVdAiBoKIakiBI2TBmwNnnBiCmE2hJLQnqu95NNedIAhS4Ah5cK1cZhs8TSYOQRAEQWgGKXCELPgWOHOpTGabk0cQVsVsv32CiEZIgTMRZy9UYsnvx1Be5ZZ13d/nKrB0xzFUuT0aSVaDuefAEQRBEER0QIF8TcRt8zbh590nMb5bAzx4eUvJ11392irsPXEOD17eEuO7NdBQQr6Vy2wKk9kUSoIgrAXLsqiqqoLbHfiS7a4sR+0kOwCg/MIFwG3XWzweyTGsT54LFy4YKks0Yrfb4XA4wGi4ZQopcCbi590nAQDz1x6SpcDtPXEOAPD1liMY2i4PH64/hGs65CM72dg9FkvLq/DOqgMY1DoHDTMTdSiRNDiC0INofFmqqKjA0aNHUVZWJni+yu3Bw72zAAB/HT6o6cAthf51beiWUy3P/v37DZUlWomPj0dubi6cTqcm+ZMCZ0I8CntHh43BlPmbsHb/aXy7rQjf3N5dZcn8Ou4Qcs76dgfeX3MI/1m6G388Pkh1WfwREqd5TpLm5RKEEbhiaAaMXng8Huzfvx92ux15eXlwOp0BClpFpRueU9Uv0/WzkmCzGavApZ6rwPGz1Za3BjnJhsoSbbAsi4qKCpw4cQL79+9HkyZNYLOp/3slBc4A3lt9AHtPnMNDQ1oKvqUpfbm1MQzW7j8NANh+pET29f/7eR+OlVzAvwcLW/+W7TyOl5ft8X0PJeeafdWyVFSFPzePZVk88c0O5KTE4ubuDYXTcD5vnnEpvt5yFH2aZ4VdNmFeotAQ5CM2xo55Nxdi1P/WGi2K5amoqIDH40F+fj7i4+MF0zAONxhHJQAgNjbWcAUux+WCKzYWCU47XDHGunOjkbi4OMTExODgwYOoqKhAbKz6HjFS4AzgwS+2AwAGt81Fx/ppAeeVrqZ02JV3GG4Pi8e/2QEAuK5jXTTOCnR53jR3Pe97KDE9HvWG193HS/G/ldVugHFdGwh2jl55GmYkIDXeiRsuqada+QRhRro2zkBGohMnSyt0LTdaFWctrChawTAM0hK0cd0R0tD6eYmcp9GClF6oEjxe6WYxb+1B2fnZFT4sT3+3E72eXeb7LuTC/WTjnwHHXl62B/Xv/wZzf+HPrzhxthwDX1yBfSfPBVzz5W9HcOnzy7Hn+FnJ8h06VYb+L6zwfe/17E94+rudYFkWE9/bgCnzN+Glpbtx7eurqxNQhHoiqqAH3hREq1ZLGAYpcDrBsixKLlTiVGm571j5P67F8ip3gLXq359tEzweDIcCk73Hw+LVn/bi8OnzvmOVnHAkFyrduFDpxl0LfxPN4+Gvfud9f2HJH9hZJKyg3f7Br9h9vBTTP90qmh/Lsig+X+mzRD769Xbe+UOny/DqT3tx4mw5vt9+DF9vOYrnFv/hO0/DmfXp1jgDAHD1xXUMliS6uCg/FQAwoGW2sYKEwaA2uQBq6kIQkQq5UHXino+34GM/K9at72/Eu+M64a6Fv6FRZkLANc0e+A4A8Ow17XB1e+GBas/xUt9nm4JVT3+dOR9w7EJltQL3xea/cMeCzbLzPHG2PGSasgrxWHe3zduEb7cVoXFWIpZM64ni85WC6bh153KmTDg9YR3eHdcJZZVuJLqoC9OTTyd1wflKNxIiuN2zk2Ox/ZEBiFN7XpiF3xznzp2LO++8E2fOnDFaFIJD5P4KIwiWZQOUNy83vr0OQHCl5+6Fv+HKgto4WVqOKg+LsvIqMAyDo8XncYSjgJ2v5Ltk1+w7hQSnA42zEnH87AUkuhxIT3QBAI4WnwfLgne9l3X7T+PiuqmylLfDp8tQ4faAZVmcF1DOKt0e7DxaY5Vz2G04cuY8YmPsSEtw4o9jZ3H4dBmykmLx7bYiANUK2oYDp7H+wN+CZS7adlTw+Klz+s4HIvTHZmNIeTMAm42JaOXNixXqoCfXXXcdLrvsMqPFECSalUt6inVgoYjyJofnftiFV3/aG3A8wVnzFvnLnlO8cyPeWAMA6NwwHav3VZ87MGswKqo86DzzRwDAC9e1C8jzqe92okWuvPAb3Z+umUPntAd65p/6dqdvEQJQvetEl1k/Iic5Fm/e2AFDXl4pmO/Vr60WLfP9NYdkyUgQVsTgcGPEPzAWNsHFxcUhLi5O1zLdbjcYhtF14UhlZSViYmJ0Ky9caA6cDjz17c6w8xBS3gDgXBBXpBev8gYAd330G2Zx5Jn6ofDctrFz1gsel0KFwJZeXOUNAPb9E3y4qOSCqPKmlMeuaKVqfgRhZqIxqK4ZYFkWZRVVvr8qjweJLgeSXDG4UOXmnVP7T06kgl69euH222/Hvffei7S0NOTk5ODhhx/mpXn++efRpk0bJCQkID8/H7fddhtKS2umqMydOxepqakAgD/++AMMw2DnTv649sILL6BRo0a+79u2bcOgQYOQmJiI7OxsjB49GidPnhSV01vGl19+iZYtW8LlcuHQoUMoLy/H3Xffjdq1ayMhIQGFhYX46aefAAA//fQTbrrpJhQXF4NhGDAM46sbwzD4/PPPeWWkpqZi7ty5AIADBw6AYRh8+OGH6NmzJ2JjYzFv3jyMHTsWw4YNw7PPPovc3Fykp6dj8uTJqKysmZrz6quvokmTJoiNjUV2djauvvpqCXdCfcgCpwNmcul9sil8a6DZofAhBEFozflKN1rO+N6Qsn9/dADindKH73feeQfTpk3D2rVrsXr1aowdOxZdu3bFpZdeCqA63MV///tfNGjQAPv27cNtt92Ge++9F6+++mpAXk2bNkWHDh0wb948PPbYY77j8+bNw/XXXw8AOHPmDPr06YObb74ZL7zwAs6fP4/77rsP1157LX788UdROcvKyvDUU0/hf//7H9LT05GVlYUpU6bg999/x4IFC5CXl4fPPvsMAwcOxNatW9GlSxe8+OKLmDFjBnbt2gUASEyUt+vP/fffj+eeew4FBQWIjY3FTz/9hGXLliE3NxfLli3Dnj17cN111+Giiy7CLbfcgg0bNuD222/He++9hy5duuD06dP4+eefZZWpFmSB04HB/6x6IoLjv2vCJQ35MfJ6NM1Ez6aZvGMMA3z9r25+x6zryiAIf+hxJ0LRtm1bPPTQQ2jSpAluvPFGdOjQAUuXLvWdv/POO9G7d2/Ur18fffr0weOPP46PPvpINL9Ro0bhgw8+8H3/448/sHHjRowaNQoA8PLLL6OgoABPPvkkmjdvjoKCArz99ttYtmwZ/vjjD7FsUVlZiVdffRVdunRBs2bNcPLkScyZMwcLFy5E9+7d0ahRI9x9993o1q0b5syZA6fTiZSUFDAMg5ycHOTk5MhW4O68805cddVVaNCgAXJzq8fqWrVq4eWXX0bz5s1x+eWXY/Dgwb72OnToEBISEnD55ZejXr16KCgowO233y6rTLUgC5wOPDS0Jb7ZKjzhXmva1knBlj+LZV1zZUFtfPbrX77vC2/tjGuCzEXzp2fTTCz/44SsMr+9ozta5CZj+OxV2Hjwb1zboQ6evrod6t//jS/Nu+M6AQBueXcDFv9+DACw78nLwDAMbu/bBP9duhu1U/Wdp0EQRjO0XR7eWrkfLXJpuyQ9iYux4/dHBxhWthzatm3L+56bm4vjx4/7vi9ZsgQzZ87Ezp07UVJSgqqqKly4cAFlZWWCO0+MGDECd999N9asWYNLLrkE8+bNw8UXX4zmzZsDAH777TcsW7ZMUJnau3cvmjZtKiin0+nkybp161a43e6A9OXl5UhPT5feAEHo0KFDwLFWrVrBbq9p49zcXGzdWh366tJLL0W9evXQsGFDDBw4EAMHDsSVV14pukOHlpACpwNZSbF4Z1wnrNp7EpN6NsJFjy72nXtqeBscLynHZ7/+5Qt8+8jQVqh0exDvdKBZThLeXX0AVW4WddLi8Nff53F52zywLItJ8zb58nnthovhdNhgt9lQXumGh2WR6IrBsz/s4slyU9f6yEh04Vx5FQ7/fR5f/XYkQN6nhrflKXAd66fh88ldsXrvKRQ2TMPxknJ8teUIWuYmo22dFJwsLccH6w5j3T/beL18fQH2nzyH34+U4H5OvDevksVl1lVtkJHo8g0+/x1ZgOW7TmBg6xwA1da1BesP4bZejX3XpMbVTDL1Wtsm9miIOqlxaF+/lpRbQhCW4d6BzVBQNxVdG2UYLUpUwTCMLDemkfhPzGcYBh5P9VzlAwcO4PLLL8ekSZPwxBNPIC0tDStXrsT48eNRUVEhqJjk5OSgT58+mD9/Pi655BLMnz8fkyZN8p0vLS3FkCFD8NRTTwVc67VyCREXF8fzoJSWlsJut2Pjxo08hQoI7SplGCZgriB3HpuXhITAEF7B2ispKQmbNm3CTz/9hB9++AEzZszAww8/jPXr1/vmCepFZDx9FqAnx/03+pJ6eG/NQcy4vCWu61gXADCwdQ4ufWEF6qfHY0yX+rxr29cTVkqyklw4/k/4kc4NM5ASH7h6prS8Ere+X63o3XBJXTw0hD/Bf8/xUuw4WoKCuqn49dAZzLi8JZwOGx4Y3AKPf7MDN3drAKA66CU38KVXwfLSpVEGCp9ciqRYB5JiY9C2TioaZSb6FLhRhXUx7dKm6NwwHSPfrF4de3nbXIzoVJeXT+3UOFxfWHOsde0UPF67DS/N6M71sHDjnyhsUONiTXA5cG3HfMF2Iggr43LYcXnbPKPFICKUjRs3wuPx4LnnnvOt+AzmPvUyatQo3HvvvRg5ciT27duHESNG+M5dfPHF+OSTT1C/fn04HMrVjIKCArjdbhw/fhzdu3cXTON0OuF2By7my8zMxNGjNZ6v3bt3o6ysTLEsXBwOB/r164d+/frhoYceQmpqKn788UdcddVVquQvWQ5dSyMAAA8PbYUbO9fj7TfaJDsJy+/phYx/4rRJYfG0njh8ugxpCU5B5Q0ABrTKweKpPVDh9qB5TqCL5ZNJnXG8pBz5afHYd6LUJ9P4bg3Qo2kmGmVKm0+QnRyLlff1RlJsjRwJLgfWTO+LQ6fLcHHdVABA50bpWHpXT5yvcKNJtry5Cl7a1knFsrt7ITtZelsRBEEQgTRu3BiVlZV46aWXMGTIEPzyyy947bXXQl531VVXYdKkSZg0aRJ69+6NvLyal4jJkyfjzTffxMiRI32rX/fs2YMFCxbgf//7X4A1TYymTZti1KhRuPHGG30LDU6cOIGlS5eibdu2GDx4MOrXr4/S0lIsXboU7dq1Q3x8POLj49GnTx+8/PLL6Ny5M9xuN+677z5VQoR8/fXX2LdvH3r06IFatWph0aJF8Hg8aNasWdh5y4UWMRiA3cagSXZSwGT7eukJsgJMpsTFoHXtFOQFmffFMNVltcpLgV1gq614pwP1MxICZGIYBk2zkwSvEaNOrXikxPF/IDkpsejUIA0OTmy4RpmJaF07BS6H8kjoDTISIsZ9QRAEYVbatWuH559/Hk899RRat26NefPmYebMmSGvS0pKwpAhQ/Dbb7/5Fi94ycvLwy+//AK3243+/fujTZs2uPPOO5Gamio7rtucOXNw44034q677kKzZs0wbNgwrF+/HnXrVntqunTpgltvvRXXXXcdMjMz8fTTTwMAnnvuOeTn56N79+64/vrrcffdd6syTy01NRWffvop+vTpgxYtWuC1117DBx98gFat9A9fxbByAspYlJKSEqSkpKC4uBjJyTQRmCAIgqjhwoUL2L9/Pxo0aIDY2FijxSEihGDPjRp6B1ngCIIgCIIgIgxS4AiCIAiCICIMUuAIgiAIgiAiDFLgCIIgCIIgIgxS4AiCIAhCArTmj5CD1s8LKXAEQRAEEQRv/DC1AsES0YH3eVEj/pwQFEiLIAiCIIJgt9uRmprq2z80Pj4+II4nQXhhWRZlZWU4fvw4UlNTJQculotlFLhXXnkFzzzzDIqKitCuXTu89NJL6NSpk9FiEQRBEBYgJ6d6+0DuJvAEEYzU1FTfc6MFllDgPvzwQ0ybNg2vvfYaCgsL8eKLL2LAgAHYtWsXsrKyjBaPIAiCiHAYhkFubi6ysrIEN0UnCC4xMTGaWd68WGInhsLCQnTs2BEvv/wyAMDj8SA/Px//+te/cP/994e8nnZiIAiCIAhCL2gnBgAVFRXYuHEj+vXr5ztms9nQr18/rF69WvCa8vJylJSU8P4IgiAIgiAihYhX4E6ePAm3243s7Gze8ezsbBQVFQleM3PmTKSkpPj+8vPz9RCVIAiCIAhCFSJegVPC9OnTUVxc7Ps7fPiw0SIRBEEQBEFIJuIXMWRkZMBut+PYsWO848eOHRNd/eFyueByuXzfvdMAyZVKEARBEITWePWNcJYhRLwC53Q60b59eyxduhTDhg0DUL2IYenSpZgyZYqkPM6ePQsA5EolCIIgCEI3zp49i5SUFEXXRrwCBwDTpk3DmDFj0KFDB3Tq1Akvvvgizp07h5tuuknS9Xl5eTh8+DCSkpI0Cc5YUlKC/Px8HD58OCpXuUZz/anuVPdoqzsQ3fWnulPdpdSdZVmcPXsWeXl5isu0hAJ33XXX4cSJE5gxYwaKiopw0UUX4bvvvgtY2CCGzWZDnTp1NJYSSE5OjrqHmks015/qTnWPRqK5/lR3qnsolFrevFhCgQOAKVOmSHaZEgRBEARBRDJRuQqVIAiCIAgikiEFTgdcLhceeugh3srXaCKa6091p7pHI9Fcf6o71V0vLLGVFkEQBEEQRDRBFjiCIAiCIIgIgxQ4giAIgiCICIMUOIIgCIIgiAiDFDiCIAiCIIgIgxQ4HXjllVdQv359xMbGorCwEOvWrTNapLCYOXMmOnbsiKSkJGRlZWHYsGHYtWsXL82FCxcwefJkpKenIzExEcOHDw/Yr/bQoUMYPHgw4uPjkZWVhXvuuQdVVVV6ViVsZs2aBYZhcOedd/qOWb3uf/31F2644Qakp6cjLi4Obdq0wYYNG3znWZbFjBkzkJubi7i4OPTr1w+7d+/m5XH69GmMGjUKycnJSE1Nxfjx41FaWqp3VWThdrvx4IMPokGDBoiLi0OjRo3w2GOP8fYytFLdV6xYgSFDhiAvLw8Mw+Dzzz/nnVerrlu2bEH37t0RGxuL/Px8PP3001pXLSTB6l5ZWYn77rsPbdq0QUJCAvLy8nDjjTfiyJEjvDysWHd/br31VjAMgxdffJF33Mp137FjB4YOHYqUlBQkJCSgY8eOOHTokO+8rv0/S2jKggULWKfTyb799tvs9u3b2VtuuYVNTU1ljx07ZrRoihkwYAA7Z84cdtu2bezmzZvZyy67jK1bty5bWlrqS3Prrbey+fn57NKlS9kNGzawl1xyCdulSxff+aqqKrZ169Zsv3792F9//ZVdtGgRm5GRwU6fPt2IKili3bp1bP369dm2bduyd9xxh++4let++vRptl69euzYsWPZtWvXsvv27WO///57ds+ePb40s2bNYlNSUtjPP/+c/e2339ihQ4eyDRo0YM+fP+9LM3DgQLZdu3bsmjVr2J9//plt3LgxO3LkSCOqJJknnniCTU9PZ7/++mt2//797MKFC9nExET2P//5jy+Nleq+aNEi9t///jf76aefsgDYzz77jHdejboWFxez2dnZ7KhRo9ht27axH3zwARsXF8e+/vrrelVTkGB1P3PmDNuvXz/2ww8/ZHfu3MmuXr2a7dSpE9u+fXteHlasO5dPP/2UbdeuHZuXl8e+8MILvHNWrfuePXvYtLQ09p577mE3bdrE7tmzh/3iiy9447me/T8pcBrTqVMndvLkyb7vbrebzcvLY2fOnGmgVOpy/PhxFgC7fPlylmWrO7iYmBh24cKFvjQ7duxgAbCrV69mWbb6h2Kz2diioiJfmtmzZ7PJyclseXm5vhVQwNmzZ9kmTZqwixcvZnv27OlT4Kxe9/vuu4/t1q2b6HmPx8Pm5OSwzzzzjO/YmTNnWJfLxX7wwQcsy7Ls77//zgJg169f70vz7bffsgzDsH/99Zd2wofJ4MGD2XHjxvGOXXXVVeyoUaNYlrV23f0HM7Xq+uqrr7K1atXiPff33Xcf26xZM41rJJ1gSoyXdevWsQDYgwcPsixr/br/+eefbO3atdlt27ax9erV4ylwVq77ddddx95www2i1+jd/5MLVUMqKiqwceNG9OvXz3fMZrOhX79+WL16tYGSqUtxcTEAIC0tDQCwceNGVFZW8urdvHlz1K1b11fv1atXo02bNrz9agcMGICSkhJs375dR+mVMXnyZAwePJhXR8D6df/yyy/RoUMHXHPNNcjKykJBQQHefPNN3/n9+/ejqKiIV/+UlBQUFhby6p+amooOHTr40vTr1w82mw1r167VrzIy6dKlC5YuXYo//vgDAPDbb79h5cqVGDRoEABr190fteq6evVq9OjRA06n05dmwIAB2LVrF/7++2+dahM+xcXFYBgGqampAKxdd4/Hg9GjR+Oee+5Bq1atAs5bte4ejwfffPMNmjZtigEDBiArKwuFhYU8N6ve/T8pcBpy8uRJuN1u3o0CgOzsbBQVFRkklbp4PB7ceeed6Nq1K1q3bg0AKCoqgtPp9HVmXrj1LioqEmwX7zkzs2DBAmzatAkzZ84MOGf1uu/btw+zZ89GkyZN8P3332PSpEm4/fbb8c477wCokT/YM19UVISsrCzeeYfDgbS0NFPX//7778eIESPQvHlzxMTEoKCgAHfeeSdGjRoFwNp190etukbyb8HLhQsXcN9992HkyJG+TcytXPennnoKDocDt99+u+B5q9b9+PHjKC0txaxZszBw4ED88MMPuPLKK3HVVVdh+fLlAPTv/y2zmT1hDJMnT8a2bduwcuVKo0XRhcOHD+OOO+7A4sWLERsba7Q4uuPxeNChQwc8+eSTAICCggJs27YNr732GsaMGWOwdNry0UcfYd68eZg/fz5atWqFzZs3484770ReXp7l604IU1lZiWuvvRYsy2L27NlGi6M5GzduxH/+8x9s2rQJDMMYLY6ueDweAMAVV1yBqVOnAgAuuugirFq1Cq+99hp69uypu0xkgdOQjIwM2O32gBUox44dQ05OjkFSqceUKVPw9ddfY9myZahTp47veE5ODioqKnDmzBleem69c3JyBNvFe86sbNy4EcePH8fFF18Mh8MBh8OB5cuX47///S8cDgeys7MtW3cAyM3NRcuWLXnHWrRo4VuF5ZU/2DOfk5OD48eP885XVVXh9OnTpq7/Pffc47PCtWnTBqNHj8bUqVN9llgr190fteoayb8Fr/J28OBBLF682Gd9A6xb959//hnHjx9H3bp1ff3fwYMHcdddd6F+/foArFv3jIwMOByOkP2fnv0/KXAa4nQ60b59eyxdutR3zOPxYOnSpejcubOBkoUHy7KYMmUKPvvsM/z4449o0KAB73z79u0RExPDq/euXbtw6NAhX707d+6MrVu38n7o3k7Q/wdiJvr27YutW7di8+bNvr8OHTpg1KhRvs9WrTsAdO3aNSBkzB9//IF69eoBABo0aICcnBxe/UtKSrB27Vpe/c+cOYONGzf60vz444/weDwoLCzUoRbKKCsrg83G7zLtdrvvzdzKdfdHrbp27twZK1asQGVlpS/N4sWL0axZM9SqVUun2sjHq7zt3r0bS5YsQXp6Ou+8Ves+evRobNmyhdf/5eXl4Z577sH3338PwLp1dzqd6NixY9D+T/exT9aSB0I2CxYsYF0uFzt37lz2999/ZydMmMCmpqbyVqBEGpMmTWJTUlLYn376iT169Kjvr6yszJfm1ltvZevWrcv++OOP7IYNG9jOnTuznTt39p33LqXu378/u3nzZva7775jMzMzIyKUhj/cVagsa+26r1u3jnU4HOwTTzzB7t69m503bx4bHx/Pvv/++740s2bNYlNTU9kvvviC3bJlC3vFFVcIhpcoKChg165dy65cuZJt0qSJKUNpcBkzZgxbu3ZtXxiRTz/9lM3IyGDvvfdeXxor1f3s2bPsr7/+yv76668sAPb5559nf/31V99KSzXqeubMGTY7O5sdPXo0u23bNnbBggVsfHy84eEkgtW9oqKCHTp0KFunTh128+bNvD6Qu4rQinUXwn8VKstat+6ffvopGxMTw77xxhvs7t272Zdeeom12+3szz//7MtDz/6fFDgdeOmll9i6deuyTqeT7dSpE7tmzRqjRQoLAIJ/c+bM8aU5f/48e9ttt7G1atVi4+Pj2SuvvJI9evQoL58DBw6wgwYNYuPi4tiMjAz2rrvuYisrK3WuTfj4K3BWr/tXX33Ftm7dmnW5XGzz5s3ZN954g3fe4/GwDz74IJudnc26XC62b9++7K5du3hpTp06xY4cOZJNTExkk5OT2Ztuuok9e/asntWQTUlJCXvHHXewdevWZWNjY9mGDRuy//73v3mDtpXqvmzZMsHf+ZgxY1iWVa+uv/32G9utWzfW5XKxtWvXZmfNmqVXFUUJVvf9+/eL9oHLli3z5WHFugshpMBZue5vvfUW27hxYzY2NpZt164d+/nnn/Py0LP/Z1iWE0acIAiCIAiCMD00B44gCIIgCCLCIAWOIAiCIAgiwiAFjiAIgiAIIsIgBY4gCIIgCCLCIAWOIAiCIAgiwiAFjiAIgiAIIsIgBY4gCIIgCCLCIAWOIAiCIAgiwiAFjiAIQoADBw6AYRhs3rxZszLGjh2LYcOGaZY/QRDWhRQ4giAsydixY8EwTMDfwIEDJV2fn5+Po0ePonXr1hpLShAEIR+H0QIQBEFoxcCBAzFnzhzeMZfLJelau92OnJwcLcQiCIIIG7LAEQRhWVwuF3Jycnh/tWrVAgAwDIPZs2dj0KBBiIuLQ8OGDfHxxx/7rvV3of79998YNWoUMjMzERcXhyZNmvCUw61bt6JPnz6Ii4tDeno6JkyYgNLSUt95t9uNadOmITU1Fenp6bj33nvhvxW1x+PBzJkz0aBBA8TFxaFdu3Y8mQiCILyQAkcQRNTy4IMPYvjw4fjtt98watQojBgxAjt27BBN+/vvv+Pbb7/Fjh07MHv2bGRkZAAAzp07hwEDBqBWrVpYv349Fi5ciCVLlmDKlCm+65977jnMnTsXb7/9NlauXInTp0/js88+45Uxc+ZMvPvuu3jttdewfft2TJ06FTfccAOWL1+uXSMQBBGZsARBEBZkzJgxrN1uZxMSEnh/TzzxBMuyLAuAvfXWW3nXFBYWspMmTWJZlmX379/PAmB//fVXlmVZdsiQIexNN90kWNYbb7zB1qpViy0tLfUd++abb1ibzcYWFRWxLMuyubm57NNPP+07X1lZydapU4e94oorWJZl2QsXLrDx8fHsqlWreHmPHz+eHTlypPKGIAjCktAcOIIgLEvv3r0xe/Zs3rG0tDTf586dO/POde7cWXTV6aRJkzB8+HBs2rQJ/fv3x7Bhw9ClSxcAwI4dO9CuXTskJCT40nft2hUejwe7du1CbGwsjh49isLCQt95h8OBDh06+Nyoe/bsQVlZGS699FJeuRUVFSgoKJBfeYIgLA0pcARBWJaEhAQ0btxYlbwGDRqEgwcPYtGiRVi8eDH69u2LyZMn49lnn1Ulf+98uW+++Qa1a9fmnZO68IIgiOiB5sARBBG1rFmzJuB7ixYtRNNnZmZizJgxeP/99/Hiiy/ijTfeAAC0aNECv/32G86dO+dL+8svv8Bms6FZs2ZISUlBbm4u1q5d6ztfVVWFjRs3+r63bNkSLpcLhw4dQuPGjXl/+fn5alWZIAiLQBY4giAsS3l5OYqKinjHHA6Hb/HBwoUL0aFDB3Tr1g3z5s3DunXr8NZbbwnmNWPGDLRv3x6tWrVCeXk5vv76a5+yN2rUKDz00EMYM2YMHn74YZw4cQL/+te/MHr0aGRnZwMA7rjjDsyaNQtNmjRB8+bN8fzzz+PMmTO+/JOSknD33Xdj6tSp8Hg86NatG4qLi/HLL78gOTkZY8aM0aCFCIKIVEiBIwjCsnz33XfIzc3lHWvWrBl27twJAHjkkUewYMEC3HbbbcjNzcUHH3yAli1bCubldDoxffp0HDhwAHFxcejevTsWLFgAAIiPj8f333+PO+64Ax07dkR8fDyGDx+O559/3nf9XXfdhaNHj2LMmDGw2WwYN24crrzyShQXF/vSPPbYY8jMzMTMmTOxb98+pKam4uKLL8b//d//qd00BEFEOAzL+gUiIgiCiAIYhsFnn31GW1kRBBGR0Bw4giAIgiCICIMUOIIgCIIgiAiD5sARBBGV0OwRgiAiGbLAEQRBEARBRBikwBEEQRAEQUQYpMARBEEQBEFEGKTAEQRBEARBRBikwBEEQRAEQUQYpMARBEEQBEFEGKTAEQRBEARBRBikwBEEQRAEQUQY/w9nTRlGAThUPQAAAABJRU5ErkJggg==",
            "text/plain": [
              "<Figure size 700x500 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "ename": "KeyboardInterrupt",
          "evalue": "",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "Cell \u001b[0;32mIn[34], line 4\u001b[0m\n\u001b[1;32m      1\u001b[0m search_types \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnaive\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m s_type \u001b[38;5;129;01min\u001b[39;00m search_types:\n\u001b[0;32m----> 4\u001b[0m     returns \u001b[38;5;241m=\u001b[39m \u001b[43mtrain_with_search_policy\u001b[49m\u001b[43m(\u001b[49m\u001b[43ms_type\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      5\u001b[0m     all_results[s_type] \u001b[38;5;241m=\u001b[39m returns\n",
            "Cell \u001b[0;32mIn[32], line 105\u001b[0m, in \u001b[0;36mtrain_with_search_policy\u001b[0;34m(search_type)\u001b[0m\n\u001b[1;32m    103\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m step \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m1\u001b[39m, k\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m    104\u001b[0m     step_action \u001b[38;5;241m=\u001b[39m actions[:, step \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m]\n\u001b[0;32m--> 105\u001b[0m     state, p, v, rewards \u001b[38;5;241m=\u001b[39m \u001b[43magent\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrollout_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstep_action\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    108\u001b[0m     pol_loss \u001b[38;5;241m=\u001b[39m mse_loss(p, policy_target[:, step]\u001b[38;5;241m.\u001b[39mdetach())\n\u001b[1;32m    109\u001b[0m     \u001b[38;5;66;03m# policy cross entropy\u001b[39;00m\n\u001b[1;32m    110\u001b[0m     \u001b[38;5;66;03m# pol_loss = torch.mean(torch.sum(- policy_target[:,step].detach() * logsoftmax(p), 1))\u001b[39;00m\n",
            "Cell \u001b[0;32mIn[31], line 113\u001b[0m, in \u001b[0;36mAgent.rollout_step\u001b[0;34m(self, hidden_s, chosen_actions)\u001b[0m\n\u001b[1;32m    111\u001b[0m \u001b[38;5;66;03m# feed dynamics\u001b[39;00m\n\u001b[1;32m    112\u001b[0m dyn_input \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mcat([hidden_s, act_enc], dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[0;32m--> 113\u001b[0m next_hidden, predicted_reward \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdyn_net\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdyn_input\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    115\u001b[0m \u001b[38;5;66;03m# get next policy + value\u001b[39;00m\n\u001b[1;32m    116\u001b[0m p, v \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpred_net(next_hidden)\n",
            "File \u001b[0;32m/scratch/naser_kazemi/tools/miniconda3/envs/ssw/lib/python3.11/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
            "File \u001b[0;32m/scratch/naser_kazemi/tools/miniconda3/envs/ssw/lib/python3.11/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
            "Cell \u001b[0;32mIn[29], line 56\u001b[0m, in \u001b[0;36mDynamicsNet.forward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m     55\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, x):\n\u001b[0;32m---> 56\u001b[0m     out \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     57\u001b[0m     next_state, reward_est \u001b[38;5;241m=\u001b[39m out[:, : \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhidden_dim], out[:, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n\u001b[1;32m     58\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m next_state, reward_est\n",
            "File \u001b[0;32m/scratch/naser_kazemi/tools/miniconda3/envs/ssw/lib/python3.11/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
            "File \u001b[0;32m/scratch/naser_kazemi/tools/miniconda3/envs/ssw/lib/python3.11/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
            "File \u001b[0;32m/scratch/naser_kazemi/tools/miniconda3/envs/ssw/lib/python3.11/site-packages/torch/nn/modules/container.py:250\u001b[0m, in \u001b[0;36mSequential.forward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    248\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m):\n\u001b[1;32m    249\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m module \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m--> 250\u001b[0m         \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m    251\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28minput\u001b[39m\n",
            "File \u001b[0;32m/scratch/naser_kazemi/tools/miniconda3/envs/ssw/lib/python3.11/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
            "File \u001b[0;32m/scratch/naser_kazemi/tools/miniconda3/envs/ssw/lib/python3.11/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
            "File \u001b[0;32m/scratch/naser_kazemi/tools/miniconda3/envs/ssw/lib/python3.11/site-packages/torch/nn/modules/linear.py:125\u001b[0m, in \u001b[0;36mLinear.forward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    124\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[0;32m--> 125\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlinear\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbias\u001b[49m\u001b[43m)\u001b[49m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "source": [
        "search_types = [\"naive\"]\n",
        "\n",
        "for s_type in search_types:\n",
        "    returns = train_with_search_policy(s_type)\n",
        "    all_results[s_type] = returns\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "search_types = [\"none\"]\n",
        "\n",
        "for s_type in search_types:\n",
        "    returns = train_with_search_policy(s_type)\n",
        "    all_results[s_type] = returns\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kaggle": {
      "accelerator": "none",
      "dataSources": [
        {
          "datasetId": 6629936,
          "sourceId": 10698698,
          "sourceType": "datasetVersion"
        }
      ],
      "dockerImageVersionId": 30886,
      "isGpuEnabled": false,
      "isInternetEnabled": true,
      "language": "python",
      "sourceType": "notebook"
    },
    "kernelspec": {
      "display_name": "ssw",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.11"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}