{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GR00T Inference Timing Analysis\n",
    "\n",
    "This notebook analyzes the inference time breakdown between:\n",
    "- **Backbone** (Cosmos-Reason2-2B / Qwen3-VL): Processes visual and language inputs\n",
    "- **Action Head** (DiT diffusion model): Generates actions using flow matching\n",
    "\n",
    "### Inference Modes Benchmarked:\n",
    "1. **PyTorch Eager**: Standard PyTorch execution\n",
    "2. **torch.compile**: PyTorch 2.0+ JIT compilation with `max-autotune` mode\n",
    "3. **TensorRT**: Optimized DiT action head using TensorRT engine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import torch\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from copy import deepcopy\n",
    "\n",
    "import gr00t\n",
    "from gr00t.data.dataset.lerobot_episode_loader import LeRobotEpisodeLoader\n",
    "from gr00t.data.dataset.sharded_single_step_dataset import extract_step_data\n",
    "from gr00t.data.embodiment_tags import EmbodimentTag\n",
    "from gr00t.policy.gr00t_policy import Gr00tPolicy\n",
    "\n",
    "# Import set_seed for reproducibility across PyTorch and TensorRT benchmarks\n",
    "from standalone_inference_script import set_seed\n",
    "set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda\n"
     ]
    }
   ],
   "source": [
    "# Configuration\n",
    "MODEL_PATH = \"nvidia/GR00T-N1.7-3B\"\n",
    "\n",
    "REPO_PATH = os.path.dirname(os.path.dirname(gr00t.__file__))\n",
    "DATASET_PATH = os.path.join(REPO_PATH, \"demo_data/droid_sample\")\n",
    "EMBODIMENT_TAG = \"OXE_DROID_RELATIVE_EEF_RELATIVE_JOINT\"\n",
    "\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "print(f\"Using device: {device}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the Policy Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the policy\n",
    "policy = Gr00tPolicy(\n",
    "    model_path=MODEL_PATH,\n",
    "    embodiment_tag=EmbodimentTag.resolve(EMBODIMENT_TAG),\n",
    "    device=device,\n",
    "    strict=True,\n",
    ")\n",
    "\n",
    "print(f\"Model loaded successfully!\")\n",
    "print(f\"Action horizon: {policy.model.action_head.action_horizon}\")\n",
    "print(f\"Num inference timesteps (denoising steps): {policy.model.action_head.num_inference_timesteps}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Dataset and Prepare Sample Observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modality config keys: dict_keys(['video', 'state', 'action', 'language'])\n",
      "Dataset loaded with 5 episodes\n"
     ]
    }
   ],
   "source": [
    "# Get modality config from policy\n",
    "modality_config = policy.get_modality_config()\n",
    "print(\"Modality config keys:\", modality_config.keys())\n",
    "\n",
    "# Load dataset\n",
    "dataset = LeRobotEpisodeLoader(\n",
    "    dataset_path=DATASET_PATH,\n",
    "    modality_configs=modality_config,\n",
    ")\n",
    "print(f\"Dataset loaded with {len(dataset)} episodes\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modality Configuration Details:\n",
      "============================================================\n",
      "\n",
      "VIDEO:\n",
      "  delta_indices: [0]\n",
      "  modality_keys: ['ego_view_bg_crop_pad_res256_freq20']\n",
      "\n",
      "STATE:\n",
      "  delta_indices: [0]\n",
      "  modality_keys: ['left_arm', 'right_arm', 'left_hand', 'right_hand', 'waist']\n",
      "  sin_cos_embedding_keys: ['left_arm', 'right_arm', 'left_hand', 'right_hand', 'waist']\n",
      "\n",
      "ACTION:\n",
      "  delta_indices: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]\n",
      "  modality_keys: ['left_arm', 'right_arm', 'left_hand', 'right_hand', 'waist']\n",
      "  action_configs:\n",
      "    [0] left_arm: rep=relative, type=non_eef\n",
      "    [1] right_arm: rep=relative, type=non_eef\n",
      "    [2] left_hand: rep=relative, type=non_eef\n",
      "    [3] right_hand: rep=relative, type=non_eef\n",
      "    [4] waist: rep=absolute, type=non_eef\n",
      "\n",
      "LANGUAGE:\n",
      "  delta_indices: [0]\n",
      "  modality_keys: ['task']\n"
     ]
    }
   ],
   "source": [
    "# Print detailed modality config\n",
    "print(\"Modality Configuration Details:\")\n",
    "print(\"=\" * 60)\n",
    "for modality_name, config in modality_config.items():\n",
    "    print(f\"\\n{modality_name.upper()}:\")\n",
    "    print(f\"  delta_indices: {config.delta_indices}\")\n",
    "    print(f\"  modality_keys: {config.modality_keys}\")\n",
    "    if config.sin_cos_embedding_keys:\n",
    "        print(f\"  sin_cos_embedding_keys: {config.sin_cos_embedding_keys}\")\n",
    "    if config.action_configs:\n",
    "        print(f\"  action_configs:\")\n",
    "        for i, ac in enumerate(config.action_configs):\n",
    "            print(f\"    [{i}] {config.modality_keys[i]}: rep={ac.rep.value}, type={ac.type.value}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Observation shapes:\n",
      "  Video keys: ['ego_view_bg_crop_pad_res256_freq20']\n",
      "    ego_view_bg_crop_pad_res256_freq20: (1, 1, 256, 256, 3)\n",
      "  State keys: ['left_arm', 'right_arm', 'left_hand', 'right_hand', 'waist']\n",
      "    left_arm: (1, 1, 7)\n",
      "    right_arm: (1, 1, 7)\n",
      "    left_hand: (1, 1, 6)\n",
      "    right_hand: (1, 1, 6)\n",
      "    waist: (1, 1, 3)\n",
      "  Action keys: ['left_arm', 'right_arm', 'left_hand', 'right_hand', 'waist']\n",
      "    left_arm: (1, 16, 7)\n",
      "    right_arm: (1, 16, 7)\n",
      "    left_hand: (1, 16, 6)\n",
      "    right_hand: (1, 16, 6)\n",
      "    waist: (1, 16, 3)\n",
      "  Language: {'task': [['pick the pear from the counter and place it in the plate']]}\n"
     ]
    }
   ],
   "source": [
    "# Extract a sample step data\n",
    "episode_data = dataset[0]\n",
    "step_data = extract_step_data(\n",
    "    episode_data, \n",
    "    step_index=0, \n",
    "    modality_configs=modality_config, \n",
    "    embodiment_tag=EmbodimentTag.resolve(EMBODIMENT_TAG), \n",
    "    allow_padding=False\n",
    ")\n",
    "\n",
    "# Prepare observation in the format expected by the policy\n",
    "observation = {\n",
    "    \"video\": {k: np.stack(step_data.images[k])[None] for k in step_data.images},\n",
    "    \"state\": {k: step_data.states[k][None] for k in step_data.states},\n",
    "    \"action\": {k: step_data.actions[k][None] for k in step_data.actions},\n",
    "    \"language\": {\n",
    "        modality_config[\"language\"].modality_keys[0]: [[step_data.text]],\n",
    "    }\n",
    "}\n",
    "\n",
    "print(\"\\nObservation shapes:\")\n",
    "print(f\"  Video keys: {list(observation['video'].keys())}\")\n",
    "for k, v in observation['video'].items():\n",
    "    print(f\"    {k}: {v.shape}\")\n",
    "print(f\"  State keys: {list(observation['state'].keys())}\")\n",
    "for k, v in observation['state'].items():\n",
    "    print(f\"    {k}: {v.shape}\")\n",
    "print(f\"  Action keys: {list(observation['action'].keys())}\")\n",
    "for k, v in observation['action'].items():\n",
    "    print(f\"    {k}: {v.shape}\")\n",
    "print(f\"  Language: {observation['language']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Timing Analysis: Backbone vs Action Head\n",
    "\n",
    "We will measure:\n",
    "1. **Full E2E inference**: Complete `get_action()` call\n",
    "2. **Backbone only**: `prepare_input()` + `backbone()` forward pass\n",
    "3. **Action head only**: `action_head.get_action()` using backbone output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import shared utilities from benchmark script\n",
    "from benchmark_inference import (\n",
    "    _rec_to_dtype,\n",
    "    prepare_model_inputs as _prepare_model_inputs,\n",
    "    benchmark_data_processing,\n",
    ")\n",
    "\n",
    "\n",
    "def prepare_model_inputs(policy, observation):\n",
    "    \"\"\"\n",
    "    Wrapper that calls the shared prepare_model_inputs with return_states=True.\n",
    "    Returns (collated_inputs, states) for use in this notebook.\n",
    "    \"\"\"\n",
    "    return _prepare_model_inputs(policy, observation, return_states=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running warmup iterations...\n",
      "Warmup complete!\n"
     ]
    }
   ],
   "source": [
    "# Warmup runs to ensure CUDA kernels are compiled\n",
    "print(\"Running warmup iterations...\")\n",
    "for _ in range(3):\n",
    "    with torch.inference_mode():\n",
    "        _ = policy.get_action(observation)\n",
    "torch.cuda.synchronize()\n",
    "print(\"Warmup complete!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Timing configuration\n",
    "NUM_ITERATIONS = 20  # Number of iterations for averaging\n",
    "\n",
    "# Storage for timing results\n",
    "timing_results = {\n",
    "    \"e2e_time\": [],\n",
    "    \"data_prep_time\": [],\n",
    "    \"backbone_time\": [],\n",
    "    \"action_head_time\": [],\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measure Full E2E Inference Time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measuring full E2E inference time...\n",
      "E2E inference time: 148.62 ± 31.66 ms\n"
     ]
    }
   ],
   "source": [
    "print(\"Measuring full E2E inference time...\")\n",
    "for i in range(NUM_ITERATIONS):\n",
    "    torch.cuda.synchronize()\n",
    "    start = time.perf_counter()\n",
    "    \n",
    "    with torch.inference_mode():\n",
    "        action, _ = policy.get_action(observation)\n",
    "    \n",
    "    torch.cuda.synchronize()\n",
    "    end = time.perf_counter()\n",
    "    timing_results[\"e2e_time\"].append(end - start)\n",
    "\n",
    "e2e_mean = np.mean(timing_results[\"e2e_time\"]) * 1000\n",
    "e2e_std = np.std(timing_results[\"e2e_time\"]) * 1000\n",
    "print(f\"E2E inference time: {e2e_mean:.2f} ± {e2e_std:.2f} ms\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measure Component-wise Inference Time (Backbone + Action Head)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measuring component-wise inference time...\n",
      "  Benchmarking data preparation (with CPU warmup)...\n",
      "  Benchmarking backbone and action head...\n",
      "\n",
      "Component-wise timing (averaged over 20 iterations):\n",
      "  Data preparation: 4.72 ± 0.72 ms\n",
      "  Backbone:         37.96 ± 2.80 ms\n",
      "  Action head:      94.28 ± 5.95 ms\n"
     ]
    }
   ],
   "source": [
    "print(\"Measuring component-wise inference time...\")\n",
    "\n",
    "# 1. Data preparation timing (with proper warmup to reduce CPU variance)\n",
    "# Uses benchmark_data_processing which includes GC and 10 warmup iterations\n",
    "print(\"  Benchmarking data preparation (with CPU warmup)...\")\n",
    "data_prep_times_ms = benchmark_data_processing(policy, observation, num_iterations=NUM_ITERATIONS, warmup=10)\n",
    "timing_results[\"data_prep_time\"] = (data_prep_times_ms / 1000).tolist()  # Convert back to seconds for consistency\n",
    "\n",
    "# 2. Backbone and Action Head timing (GPU-bound)\n",
    "print(\"  Benchmarking backbone and action head...\")\n",
    "for i in range(NUM_ITERATIONS):\n",
    "    collated_inputs, states = prepare_model_inputs(policy, observation)\n",
    "    \n",
    "    # Backbone timing\n",
    "    torch.cuda.synchronize()\n",
    "    start_backbone = time.perf_counter()\n",
    "    \n",
    "    with torch.inference_mode():\n",
    "        backbone_inputs, action_inputs = policy.model.prepare_input(collated_inputs)\n",
    "        backbone_outputs = policy.model.backbone(backbone_inputs)\n",
    "    \n",
    "    torch.cuda.synchronize()\n",
    "    end_backbone = time.perf_counter()\n",
    "    timing_results[\"backbone_time\"].append(end_backbone - start_backbone)\n",
    "    \n",
    "    # Action head timing\n",
    "    torch.cuda.synchronize()\n",
    "    start_action = time.perf_counter()\n",
    "    \n",
    "    with torch.inference_mode():\n",
    "        action_outputs = policy.model.action_head.get_action(backbone_outputs, action_inputs)\n",
    "    \n",
    "    torch.cuda.synchronize()\n",
    "    end_action = time.perf_counter()\n",
    "    timing_results[\"action_head_time\"].append(end_action - start_action)\n",
    "\n",
    "print(f\"\\nComponent-wise timing (averaged over {NUM_ITERATIONS} iterations):\")\n",
    "print(f\"  Data preparation: {np.mean(timing_results['data_prep_time'])*1000:.2f} ± {np.std(timing_results['data_prep_time'])*1000:.2f} ms\")\n",
    "print(f\"  Backbone:         {np.mean(timing_results['backbone_time'])*1000:.2f} ± {np.std(timing_results['backbone_time'])*1000:.2f} ms\")\n",
    "print(f\"  Action head:      {np.mean(timing_results['action_head_time'])*1000:.2f} ± {np.std(timing_results['action_head_time'])*1000:.2f} ms\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results Summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "TIMING SUMMARY\n",
      "================================================================================\n",
      "         Component  Mean (ms)  Std (ms)  Max Freq (Hz)\n",
      "Full E2E Inference 148.622379 31.658442       6.728462\n",
      "  Data Preparation   4.720365  0.724041     211.848030\n",
      "    Backbone (VLM)  37.961487  2.802250      26.342488\n",
      "       Action Head  94.281011  5.948398      10.606590\n"
     ]
    }
   ],
   "source": [
    "# Create summary DataFrame\n",
    "summary_data = {\n",
    "    \"Component\": [\n",
    "        \"Full E2E Inference\",\n",
    "        \"Data Preparation\",\n",
    "        \"Backbone (VLM)\",\n",
    "        \"Action Head\",\n",
    "    ],\n",
    "    \"Mean (ms)\": [\n",
    "        np.mean(timing_results[\"e2e_time\"]) * 1000,\n",
    "        np.mean(timing_results[\"data_prep_time\"]) * 1000,\n",
    "        np.mean(timing_results[\"backbone_time\"]) * 1000,\n",
    "        np.mean(timing_results[\"action_head_time\"]) * 1000,\n",
    "    ],\n",
    "    \"Std (ms)\": [\n",
    "        np.std(timing_results[\"e2e_time\"]) * 1000,\n",
    "        np.std(timing_results[\"data_prep_time\"]) * 1000,\n",
    "        np.std(timing_results[\"backbone_time\"]) * 1000,\n",
    "        np.std(timing_results[\"action_head_time\"]) * 1000,\n",
    "    ],\n",
    "    \"Max Freq (Hz)\": [\n",
    "        1000 / (np.mean(timing_results[\"e2e_time\"]) * 1000),\n",
    "        1000 / (np.mean(timing_results[\"data_prep_time\"]) * 1000),\n",
    "        1000 / (np.mean(timing_results[\"backbone_time\"]) * 1000),\n",
    "        1000 / (np.mean(timing_results[\"action_head_time\"]) * 1000),\n",
    "    ]\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(summary_data)\n",
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"TIMING SUMMARY\")\n",
    "print(\"=\"*80)\n",
    "print(df.to_string(index=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "TIME BREAKDOWN (%)\n",
      "================================================================================\n",
      "Data Preparation: 3.4%\n",
      "Backbone (VLM):   27.7%\n",
      "Action Head:      68.8%\n"
     ]
    }
   ],
   "source": [
    "# Calculate percentage breakdown\n",
    "total_component_time = (\n",
    "    np.mean(timing_results[\"data_prep_time\"]) + \n",
    "    np.mean(timing_results[\"backbone_time\"]) + \n",
    "    np.mean(timing_results[\"action_head_time\"])\n",
    ")\n",
    "\n",
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"TIME BREAKDOWN (%)\")\n",
    "print(\"=\"*80)\n",
    "print(f\"Data Preparation: {100*np.mean(timing_results['data_prep_time'])/total_component_time:.1f}%\")\n",
    "print(f\"Backbone (VLM):   {100*np.mean(timing_results['backbone_time'])/total_component_time:.1f}%\")\n",
    "print(f\"Action Head:      {100*np.mean(timing_results['action_head_time'])/total_component_time:.1f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABjYAAAHqCAYAAACne3d+AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAA6+5JREFUeJzs3XdUFNfbB/DvLnVBuiKiAioIdrH3HhUjamKKxtg1auxdkxg1mtiNMUZjNLGXJMYSozFRwV5RsSKKIFhABKWzwO7e9w9f9udmlyowlO/nnD3HvXNn5pndlZm5z9x7ZUIIASIiIiIiIiIiIiIiohJALnUAREREREREREREREREucXEBhERERERERERERERlRhMbBARERERERERERERUYnBxAYREREREREREREREZUYTGwQEREREREREREREVGJwcQGERERERERERERERGVGExsEBERERERERERERFRicHEBhERERERERERERERlRhMbBARERERERERERERUYnBxAYVqYSEBEycOBHVqlWDiYkJZDIZAgMDpQ6rVHJzc4Obm5vUYeRo8+bNkMlk2Lx5s9ShEBER0WuGDBkCmUyGhw8fSh1KqfPw4UPIZDIMGTLkjbfVoUMHyGSyNw+KiIiKjEwmQ4cOHaQOo1TJ63XLiRMnIJPJMG/evEKN603MmzcPMpkMJ06cyPU6/G1RWcLEBuUo88are/fub7ytGTNmYPXq1ahbty5mzZqFuXPnwsnJqQCiLL0yP//cvkpCMqO4uXLlCoYPHw4PDw9YWlpCoVCgRo0aGDhwII4ePSp1eGVaSUnQEVHZlZvz9Ot/x5KTk7F9+3Z88MEHqFmzJhQKBWxtbdG+fXvs2rXL4D4yb2qze+V0U+7m5pan64mSlswwdAwKhQKenp6YOnUqnj9/LnWIRERURF4/Nzs5OUGlUhmsFxQUxPtoCXXq1AkymQx169aVOhTKpcxkUFYvW1tbqUOkMsZY6gCobPnrr79Qs2ZNHDx4UOpQSgxbW1vMnTtXr3z+/PmwsbHBpEmT9OoDwPHjx4sgupJNo9Fg2rRp+Pbbb2FsbIxOnTqhV69eMDExQWhoKA4dOoTt27fjq6++wpw5c6QOl4iIirEaNWrg448/Nrjs9Zu806dPY+DAgXBwcEDnzp3Rt29fREdHY+/evfjoo49w9uxZrFmzxuB2+vbtm+XNf05P5k2aNAlxcXE6ZZs3b0Z4eDgmTpyodyNqa2uLRYsWYdasWahcuXK22y4uHBwcMG7cOO372NhYnDhxAitXrsSBAwdw9epVWFtbSxghEREVJWNjYzx79gyHDx9Gr1699Jb//PPPkMuled43KCgIFhYWkuy7OAgNDdU2kt++fRsXL15E8+bNizSGZs2aISgoCOXLly/S/ZYGjRs3Rs+ePfXKzc3NJYiGyjImNqhIPX36FO3atZM6jBLF1tbW4FOY8+fPz3IZ8KqBhbL3xRdf4Ntvv0XDhg2xZ88evc8sNTUVa9asQWxsrEQREhFRSeHu7p6roQycnJywbds2fPDBBzA1NdWWf/PNN2jevDl++OEHDBo0CM2aNdNb97333kO/fv3yFd9/H4QAXj11Fx4ejkmTJhl8UtXW1haVKlXK1/6kUL58eb3vQAgBX19fHDp0CHv27MGwYcOkCY6IiIpcq1atcP36dfzyyy96iQ2VSoXt27ejS5cuOHnyZJHH5uXlVeT7LE5++eUXCCEwbdo0LF++HD///HORJzYsLCzK/PeQX02aNCnWQ3hR2cGhqCjfMscvDAsLw+rVq+Hl5QUzMzO4urpi/vz50Gg0enWFEDh58qS2m9p/ny48cOAAOnfuDDs7O5ibm6Nu3bpYvnw51Gq1Tr3X52U4ePAgWrduDSsrK52b8vT0dKxcuRKNGjWCpaUlrKys0LZtW/z5559vdCz/jbdr165wcHCAubk53NzcMHDgQNy6dUunXl5iKSiGhvB5fXzGTZs2oV69elAoFKhWrRpWr14N4FUDwIoVK+Dp6Qlzc3N4eHhg69atBvdR0Md14MABNGvWDBYWFqhQoQKGDRuGZ8+eaZfHx8fD0tISderUMbi+RqOBm5sb7OzskJqamu2+QkJCsHTpUjg4OODIkSMGE0EKhQLTp0/H/PnzdcpjYmIwadIkVKtWDWZmZnB0dMQHH3yg970D//tthYaGYvny5dphR2rXro3du3cDePU5fv7553Bzc4O5uTnq16+Pv//+W29bmWNoK5VKzJo1Cy4uLjA3N0etWrXw/fffQwiht45KpcLKlSvRoEEDKBQK2NjYoGPHjgZ7Tb3+/+rff/9Fq1atYGFhAQcHBwwePDjLBM+NGzfQr18/VKpUCaampnB1dcX48eP16r8+nnhISAjeeecd2NnZwdLSEl26dMH169f16oaHhyM8PDxPw60QERVnDRs2xMcff6yT1ACAihUrYtSoUQCAU6dOSRGaHkNjVb8+HvW5c+fQsWNHWFlZoUKFCvj000+1599Dhw6hZcuWsLS0RMWKFTFjxowshwLJ7fVffshkMnTr1g3Aq/P3614/r37xxReoUaMGTExMdM4zYWFhGDFiBFxcXGBmZoZKlSphyJAhCA8P19vXvn370L9/f7i7u8PCwgI2NjZo27Yt/vjjj1zHm56ejg8++AAymQwzZszQObefOXMG7du3h6WlJRwcHPDhhx/i0aNHWW4rOTkZc+fOhZeXF8zNzWFvb4+3334bZ8+e1al34MAByGQyLF++XKd81apVkMlkqFKlik65UqmEubk5OnbsqC17/Rpz586daNiwIRQKBSpVqoSJEyfmeF1GRFQYFAoF+vXrh0OHDiE6Olpn2V9//YVnz55lmfB++vQp5s6dixYtWsDR0RFmZmZwc3PDp59+qretkJAQWFlZoUqVKnr3QFktM9QeUpD3jtkN6WtobqaCbivIjlqtxubNm+Hg4ICvv/4a7u7u2L17N5KTk7NcJ7dtL5lx5qZdJ7s5NqKjozF58mS4u7vDzMwM5cuXR9++ffX25+7uDisrK6SkpBiMu1evXpDJZLh37x6AV20aS5YsQfv27eHs7AxTU1M4Oztj0KBBePDgQbaf288//4x69erB3NwclStXxuTJk5GYmJjtOq8rynap139PmzdvRqNGjWBhYaHzm09MTMTcuXNRp04d7dCs3bp1w5kzZwxu8/bt2+jZsyesrKxgY2ODHj164NatWwavV7ObmyS7eV4Lo23jddHR0Zg6dSo8PT2hUChgb2+P5s2ba6/B7t+/D7lcjh49ehhcPzExEeXKlWNC7nWCKAdhYWECgOjWrZtO+eDBgwUA0bdvX1G+fHkxZMgQMWHCBOHi4iIAiM8++0xbd9++fWLu3LkCgHB1dRVz584Vc+fOFZs2bdLWmTVrlgAgKleuLIYNGyYmT54smjRpIgCI9957T2ffmzZtEgBEjx49hLGxsejTp4+YMWOGGD16tBBCCKVSKTp06CAAiIYNG4rx48eL0aNHi6pVqwoA4vvvv8/3sWSaMmWKACDs7e3FsGHDxKxZs8SAAQOEk5OT+Pbbb7X18hpLbmV+lllxdXXVW575HfTu3VvY2NiIQYMGiQkTJojKlSsLAGLDhg3i008/FRUrVhTDhw8XY8aMEXZ2dgKAOHnypM62Cuq4Mr/Lnj17ChMTE9G/f38xe/Zs0bFjRwFAuLu7ixcvXmjrDxs2TAAQZ8+e1dvWkSNHBAAxduzYHPf7+eefZ/ndZic6OlrUqFFDABAdOnQQs2bNEh9++KEwMjISFhYW4vTp0zr1M39bvXv3Fk5OTmLkyJFi9OjRwtbWVshkMnHkyBHx9ttvi2rVqolPP/1UDBs2TJibmwsTExMREhKis6327dsLAMLX11dUqVJFTJw4UUycOFFUqVJFABBTpkzRqa/RaETv3r0FAFGzZk0xdepUMXr0aO13unLlSp36md/FO++8I0xNTUXfvn3F1KlTRdOmTQUA0bp1a73P48CBA8LMzEwoFArRr18/MX36dPH2228LAMLDw0Pnu8v8W9K+fXvh4OAg2rVrJ6ZMmaKN0c7OTkRFRQkhhHj58qWYO3eusLGxETY2Ntq/GXPnzhX+/v55+s6IiApTVtdJ+bFs2TIBQOc6Qoj/nb937dr1xvt4XeZ5JSwszODyzHPY68v9/f0FANG9e3dhbm4uevfuLaZOnSoaNWokAIgBAwaI3bt3C3Nzc/Hhhx+KyZMni5o1awoAYv78+Xr7yMv1X3YACE9PT4PLfH19BQBx9OhRg8ffo0cPUblyZTF8+HAxdepUsXnzZiGEEBcuXBA2Njbaa83p06eL999/XxgbGwtHR0fx4MEDne15enqKevXqicGDB4tZs2aJ4cOHiwoVKggAYvXq1Tp1M383gwcP1pYlJCSITp06CZlMJlasWKFT/9ixY8LExESYmZmJQYMGiVmzZommTZuKqlWrivr164v/3talpqaKZs2aCQCiUaNGYubMmWLIkCFCoVAIIyMj8dtvv2nrvnjxQsjlctGjRw+dbfTq1UsAEADEvXv3tOV+fn5632fmb7Rv377C0tJSfPTRR2Ly5MmiVq1aAoD46KOPDH43RESF4fVz88WLFwUAsXz5cp06vr6+wt7eXiiVSmFmZqZ377xr1y5haWkpevXqJSZMmCCmTp0qOnXqJACI6tWri7i4OJ36mfdSffr00Zalp6eLJk2aCLlcLvz8/HTqZ94Xva4g7x0NtQdkyjz/va4g2wpycujQIQFAfPrpp0IIIebPny8A6LQPvS63bS95bdfJvKaZO3euTnlISIj2Hrtr165i6tSpYuDAgcLCwkJYWlqKCxcu6H1uO3bs0Iv7+fPnwsTERDRv3lxbdv78eWFqaiq6desmPv30UzF9+nTh6+srjIyMhL29vXj48KHONjK37+vrKywsLMTQoUPFzJkzRePGjQUA0aJFC5Genq6zjqHfVkG132R+ZqNGjcq2XmbcPXr00LYVzJw5U/sdxMbGijp16mjbGSZNmiSGDRsmHBwchLGxsdi3b5/O9m7evCmsra2FXC4X7733npg9e7bo3LmzsLa2Fm3bttW7Xs3cv6G2g8z/q//9vRVW20amu3fvikqVKgkAok2bNmLGjBli7NixokOHDsLOzk5br1OnTkIul4uIiAi92H/88UcBQCxbtizbz78sYWKDcpRTYqNatWri6dOn2vLnz58LW1tbYWVlJdLS0nTWMfQHVggh/v33X+0+kpKStOUajUaMHj1aABB79uzRlmf+IZLL5Xo3qUII8dlnnwkAYs6cOUKj0WjLExISRJMmTYSpqal48uRJvo/l4MGDAoCoV6+eiImJ0dl3RkaGzh+wvMaSW2+S2LC3t9e5GY+IiBCmpqbCxsZG1KxZU0RHR2uXXbhwQXsifV1BHVfmdwlAHDlyRGdZZmPHuHHjtGWZF6ZDhgzR29Z7770nAIjAwMAc95t5Uj927FiOdV83dOhQAUDMnj1bpzzz4szd3V2o1WpteeZv67+fa+Zx2NraijZt2uj87n/99VcBQIwfP15nH5kXoJ6enjoX0nFxccLT01PIZDJx+fJlbfmWLVu0/+de//2Gh4eL8uXLC2NjY53fQeZ3YWxsLM6cOaMtV6lU2s/r/Pnz2vKYmBhhbW0tKleurHcBtmvXLr3vLvNvCQCxePFinfpffPGFACAWLVqkU57dBTkRUXGQ+betRo0aOknY119///13jttRqVSiXr16QiaTiZs3b+ose73ROKt9REZG5jn2N0lsABD79+/Xlqenp4v69esLmUwmypcvLy5duqRdlpCQIBwdHYW9vb3OzXder/+yA0A4ODjofCYTJkwQ9evXF8bGxmLixIlZHn/Dhg1FbGyszrL09HTh5uYmrKysxNWrV3WWnT59WhgZGYmePXvqlP830SGEEImJiaJevXrCxsZGJCcna8v/m9iIiooS3t7ewsTERGzbtk1nG2q1WlSvXl3IZDKdByg0Go346KOPtN/H6zIbiQYMGKBznXb16lVhamoqbG1tRUJCgra8UaNGwsrKSmRkZGj3aWtrKzp37iwAiPXr12vrzpkzRwAQp06d0pZl/kZtbGzE3bt3teUpKSmiZs2aQi6X5+t6l4goP/7bhlG3bl1Rp04d7fLIyEhhbGysvd8ylNh49uyZSExM1Nt25j3WwoUL9Zb169dPABBr164VQggxffp0g/eOQmSf2CiIe8f8JjYKoq0gJ++++67OveWDBw+ETCYTbdq00aubl7aXvLbrZJXYaNWqlTAyMtJrnwgODhZWVlaiXr162rL79+8LAMLHx0cv9u+//14AEGvWrNGWxcXF6V1zCPHqoQG5XC5GjBihU575vZiamorr169ry1+/Bvhv0s7Qb6ug2m8yP7PGjRsbvB4NCgrSidvS0lLcuHFDbzuZsW/YsEGn/NmzZ6Jq1aqiQoUKIjU1VVue+Zvdvn27Tv3Zs2drr4PeJLFRFG0bmQ/u/PTTT3oxPXr0SPvvzP/T8+bN06uX+V29/v+wrGNig3KUU2Ljl19+0Vsnc9l//4BlldjIfCIsPDxcb1lcXJyQyWSib9++2rLXnyz/L7VaLezs7ESNGjV0/mBn+vPPP/Uy0nk9Fh8fHwFA76mLgoglt94ksWHoicnMp0+2bNmit6x69erCxcVF+74gjyvzu+zSpYvessTERGFrayusra11kgXe3t7C0tJSxMfHa8uio6OFqampaNq0aY77FEIILy8vAUDn5jsnaWlpwtzcXDg4OOg0TmR666239G70M38/WX2ugP4TLiqVSpiYmIh27drplGd1MhdCiG3btumdbDO/04sXL+rV//rrrwUA8dVXX2nLMr+LQYMG6dXPXPb6E6crV64UAMTWrVv16gvxqpGkfPny2veZf0uqVaum832+vuzdd9/VKWdig4iKu9dvbLJ6GWpU/6/MG7Nhw4bpLcs8f2f3unbtWp5jf5PERseOHfXqf/XVVwKAGDp0qN6yzB6XoaGh2rK8Xv9lJ7vPpk2bNgZvbDOP/8CBA3rL9u7dq3eefN27774r5HK5zrVIVlasWCEAiBMnTmjLXk9shISEiBo1aggLCwuDSbCTJ09m2XD08OFDYWRkpNdAVb16dWFiYqJzo5xp5MiReufvqVOn6jQyBQQECOBVLyEXFxfx4Ycfauu2adNGKBQKncahzN/ol19+qbe/zGV//vlndh8TEVGB+W8bRuZ9S+aT9osXL9Y5dxpKbGRFo9EIa2tr0aFDB71lcXFxws3NTSgUCrF69Wohk8lEs2bNtEnj12WX2CiIe8f8JjbetK0gJ9HR0cLExETUrFlTp7xNmzYG789z2/YiRN7bdQwlNq5evZrl9ZgQ/+s98vpDKC1bthTGxsbi2bNnOnWbNWsmTExMxPPnz3OMXQgh6tWrJ9zc3HTKMr+X/yY8hPjfNUDdunV1yv/72yrI9pvXH3Ax9MrsaZEZ9+TJk/W28fz5c2FkZCQ6depkcB+rV68WAMTBgweFEK8ezAQg6tevr1c3s83oTRMbhd22kZmc/O//U0PS09NFxYoVhaurq862r1+/LgCI999/P8dtlCWcPJzeWOPGjfXKMsfijYuLy9U2Lly4AEtLS/zyyy8GlysUCty9e1ev3NDEmsHBwXj58iWcnZ315kYAgOfPnwOAwe3l9lguXboEMzMztG/f3vABFUAshalhw4Z6ZZmTg2a17OLFi9r3hXFcbdu21SsrV64cGjZsiBMnTiA0NBTu7u4AgFGjRmH06NHYuXMnRo8eDQDYunUr0tPTMXLkyFzvM6/u3r0LpVKJjh07wsLCQm95x44dcfToUQQGBuodT1afa2hoqN4yIyMjODo64unTpwbjMPRZZZZdu3ZNW3bt2jVYWFgY/H+SOS52YGCg3rLc/j+4cOECAODixYsGxwNVKpWIiYlBTEwMypcvry1v2LAh5HLdKZ7y+jeDiKi46datG44cOZKvdX/88UcsWrQI3t7e+O6777Kst2vXrnxPHl7Q8nMtAbwas7xatWoA8n/9lxVPT0+d+nFxcbh69SqmTJmCLl264Pfff8c777yjt56h82TmOS44ONjg2NtRUVHQaDS4d+8emjRpAuDVuMmLFy/G33//jfDwcL15JQyd1+/evYvWrVtDpVLBz8/P4MSpmeM0Gzr/u7q6omrVqjrjSickJCA0NBS1atXSmx8DeHUNsGHDBgQGBmLgwIHashUrVsDf3x8tWrSAv78/AKBTp07o2LGj9redkpKCS5cuoW3btnrzxAAFc19ARFTQPv74Y8ycORO//PILmjdvjk2bNsHb29vg+ep1e/fuxfr163H16lW8fPlSZ+4nQ3/TbWxssGPHDrRr1w4TJkyAlZUVdu7cCWPjvDW9FeS9Y169aVtBTrZs2YKMjAzt+SfToEGDcObMGfzyyy9YsmSJtjy3bS+ve5NzUeb5/9mzZwbP/5nXGXfv3kXdunUBAAMHDsT58+exa9cuTJw4EcCruRIuXboEX19fnXth4NXcHqtWrcLFixcRExOjMweZoXMrkP01wO3bt5Genp7luoXRfjNq1Cj8+OOPOdYzdI11+fJlqNVqpKWlGfyM79+/r42nZ8+e2uugNm3a6NV9vc3oTRR228alS5cAAF27ds0xFhMTEwwdOhSLFy/Gv//+i+7duwMANmzYAACF2uZVEjGxQW/M2tparyzzxJ3bSR9fvHgBlUpl8I9sJkMTSVWsWNHgtoBXEwvdvn07T9vL7bHEx8ejcuXKen/ACjKWwpTdcWa17PWTbWEcl6Hv8vXy+Ph4bdlHH32EadOmYePGjdrExs8//4xy5cqhf//+udqfk5MT7t69iydPnsDT0zNX6yQkJGQba+YFX2a91+XnM8/IyDC4H0P7N/Q5JSQkoGrVqgUa6+v/DzJ/Bz/88IPBfWRKTk7WOfkXxN8MIqLSYuPGjfj0009Rr149HD16FOXKlZM6pFzJz3kNgM65Lb/Xf7lla2uLTp06Yc+ePfDw8MCMGTMMJjayu57csWNHtvvIjO/Fixdo2rQpIiIi0Lp1a3Tp0gW2trYwMjJCYGAgDhw4gLS0NL317927h5cvX6JVq1baBpL/yjy3Ozo6GlxesWJFvcRGVscFGL4GaNu2LYyMjODv74/Zs2fD398fderUgaOjIzp27IgtW7bgzp07ePLkCdLT03UmDn8dz/FEVBxVqFABvr6+2L17N95//30EBwfj+++/z3adFStWYNq0aahQoQK6du2KKlWqQKFQAABWrVpl8G86ADRq1Aiurq4IDQ2Fj48PatSoked4C/LesSj2/XpbQU5+/vlnyGQyvcTGBx98gAkTJmDr1q34+uuvtfvMbdtLbo8hp3NR5vn/0KFDOHToUJb1Xr8++fDDDzFp0iRs375dm9jYtm0bAOgd5++//44PP/wQ5cqVQ7du3eDm5gYLCwvtZNbh4eEG95dde8nDhw+RmJgIBweHbI9Jinap7K6xzp49i7Nnz+YYT26ug95UYbdtZB5D5cqVcxXPJ598giVLlmDjxo3o3r07lEolduzYgWrVqqFLly652kZZwcQGFQvW1taQyWSIiYnJ03oymczgtgCgb9++2LNnT4HE91+2trbaJ/WyO8EWRSxSKIzjevbsWbblNjY22jIrKysMGDAA69evR2BgIJKTkxEUFIQRI0bkukGodevWOHHiBI4fP45OnTrlap3M484q1qioKJ16heXZs2dwcXHRKwN0Pydra2tER0cb3EZBxJq57s2bN7NsjCEioqxt2LABo0aNQu3atXH8+PEsb0hLq/xe/+WVu7s77O3tERISgri4ONja2uosz+568uDBg+jZs2eO+/j5558RERGBBQsW4IsvvtBZtnjxYhw4cMDger169UK1atUwb9489OjRA4cPH4alpaVOncxze1bn9P9el+TnesXa2hqNGzfG2bNnkZqaijNnzmDQoEEA/tfL09/fX/tEcFaJDSKi4mr48OHYu3cvhgwZAnNzcwwYMCDLuiqVCgsWLEClSpUQGBio06AqhMDSpUuzXHf69OkIDQ2Fg4MDfvvtNwwePBg9evQo0GPJDblcjvT0dIPLXn8YriidO3dO2yvAzc3NYJ2oqCgcPnwYvXr1ApD7tpeCknlu/P777zFu3LhcrWNvb48ePXpg//79CA4OhqenJ7Zv3w4bGxv4+vrq1J03bx7Mzc1x5coVeHh46CzbvXt3lvvIrr1EJpPBysoqx2OSol0qu2usqVOnYvny5TluI6/XQQC0vxVDSTdDv//CbtvIvPZ88uRJrupXq1YNXbt2xZ9//ono6GgcPXoUL1++xNSpUw1+pmVZ4f9VIMqF5s2bIzY2Vtvl7E3UqlUL1tbWCAgIKLCnFv6rWbNmSEtLw8mTJyWPRQqFcVynT5/WK0tKSkJgYCCsra1RvXp1nWWjRo0C8KpRaOPGjQDy1iVvyJAhMDIywk8//aTtepmVzKdxvLy8YG5ujsuXLyMlJUWvXmb3x5y6NL8pQ59VZpm3t7e2zNvbWztkxH8VRKyZw2WcP38+39vIiZGREZ/wJKJSKTOpUatWLfj5+aFChQpSh1TkCvL6LzsqlQqJiYkAAI1Gk6t18nqOyxy2oHfv3nrLDJ23Xzd37lwsWLAAp06dgo+PD5KSknSWN2jQIMvthIeH49GjRzplmddNISEhBm+gs7oG6NixI1JSUrB27VokJCRoH/xwcXFBjRo14OfnB39/f1haWqJp06bZHhMRUXHTrVs3VK5cGU+ePEGfPn1gZ2eXZd2YmBjEx8ejZcuWek+JBwQE6A01mOnQoUNYs2YN2rdvj4CAANjZ2WHo0KFZNkoXJjs7O0RHR+s17CYnJxf6eTcrP//8MwDAx8cHw4cP13v17dtXpx6Q+7aXgpLfe9zMnhnbt2/H2bNnERYWhvfeew/m5uY69R48eIBatWrpJTUiIyMRGhqa5fazuwaoU6dOlsNQAcWvXapp06aQyWS5/owzr4POnDmjtyyzzei/Mv9/G7oOen347kyF3baROSTXv//+m+t1Ro0ahYyMDGzZsgUbN26EkZERhg4dWijxlWRMbFCxMGHCBADAsGHDEBsbq7c8KioKQUFBudqWsbExxowZg/DwcEybNs3gH+5bt25lme3NjbFjxwIAJk6cqO2ylkmlUmkvXIoiFikUxnEdO3YM//zzj07Z119/jbi4OAwaNEjv6Qxvb280bdoUO3bswO+//4769esbHL8xK+7u7pgxYwZiYmLg4+ODsLAwvTpKpRIrV67UjvtoamqK/v37IyYmBosWLdKpe+TIEfzzzz9wd3dH69atcx1HfixYsEDnKYP4+HgsXLgQMpkMgwcP1pZn/nv27Nk639GjR4+wcuVKGBsbZ/ukUk6GDh0KKysrfP755wa7tKakpGjHqswve3t7xMTEQKlUvtF2iIiKk40bN2LUqFHw8vKCn59fll3rS7uCvP7Lzpo1a5CRkYE6derA3t4+V+v07t0bLi4uWLlyJU6dOqW3PCMjQ+cG29XVFYD+TffOnTtx+PDhHPf3xRdf4Ouvv8bp06f1khtt2rRBtWrV8Ndff+lsXwiBzz77zOADAIMHD0ZGRgZmz54NIYS2/MaNG9i8eTNsbGzQp08fnXUye2EsWbIEcrkcHTp00Fnm5+eHy5cvo3Xr1jAxMcnxmIiIihMjIyPs378f+/bt07uX+y9HR0coFApcvXpV54G2ly9fYvz48QbXiYqKwtChQ2FnZ4ft27fDzc0NP/30E6KjozF48GCdv8VFoWnTpsjIyNAZUlEIgdmzZxf5UNjAqwbo3377DZaWlvjtt9+wceNGvddvv/2GKlWq4PDhw9rehblteykozZo1Q/PmzbFr1y78+uuvess1Go3BJMvbb78NOzs77NixA1u3bgWgPwwV8Op6ISQkRCdupVKJMWPGZJt02Lp1K27cuKF9//o1wJAhQ7I9puLWLuXk5IQPPvgA586dw7Jlywz+37h48aL2/56LiwvatWuHGzdu6A0R+s033xicNyXzAYytW7fqPNRy/vx5g8OMFnbbRtOmTdG0aVOcOnVKO1fG6wwlYHx9feHs7Ixvv/0WJ0+exNtvvw1nZ+d8x1BacSgqKha6d++OOXPmYMGCBXB3d0f37t3h6uqK2NhYhISE4PTp01i4cCFq1aqVq+3Nnz8fV69exerVq3Ho0CG0a9cOjo6OePLkCW7evInr16/j/Pnz+W5I6NGjB6ZNm4bly5fDw8MD77zzjnb7x48fx7Rp0zBp0qQiiUUqBX1cPXv2hK+vL9577z24ubnhwoUL8Pf3R40aNfDVV18ZXGf06NEYPnw4gPxNoLRw4UIolUp8++238PT0RKdOnVC3bl2YmJggLCwMx44dQ2xsLBYuXKhdZ8mSJTh58iQWLlyIc+fOoXnz5nj48CF+//13WFhYYNOmTYXeRbZmzZqoW7eu9omWP/74A48fP8aUKVO0E5gCry6k9u7diwMHDqB+/fro2bMnkpOT8euvv+LFixdYsWKFXk+YvKhQoQJ27dqF999/Hw0aNED37t3h5eWFtLQ0PHz4ECdPnkSrVq3yPZku8GrS0oCAAPj4+GgnKm3Xrh3atWuX720SERWGkJAQgxMgZpo1axbMzc3h5+eHTz75BEIItGvXDuvWrdOr27BhQ71GZwDYs2dPlhM7enl5FZuJxXOroK//YmJidL6D+Ph4XL16FadOnYKZmVmO46m/zszMDHv27IGPjw/at2+PTp06oV69epDJZAgPD8fp06fh4OCg/T4GDhyIJUuWYPz48fD394erqyuuX7+O48eP491338XevXtz3Odnn30GuVyO2bNno3v37jhy5AjKlSsHuVyOn376CT169ECXLl3w4YcfwtnZGX5+foiMjET9+vV1GjsAYMaMGTh06BC2bduGoKAgdO7cGdHR0fj111+hUqmwYcMGvWEr2rRpAxMTEzx//hze3t46TzN37NhR20OWw1ARUUnVpEkTnfulrMjlcnz66adYsWIFGjRoAF9fXyQkJODvv/+Gq6urXuOiEAKDBg3C8+fPsWfPHu3kwe+99x6GDx+On3/+GStXrsTUqVML5bgMGTduHDZt2oQRI0bg6NGjqFChAk6fPo24uDg0aNBAOyFzUfn111+RlJSEwYMHZzl8tFwux6BBg/DNN99gy5YtmDlzZp7aXgrKrl270LFjR/Tr1w+rVq1Co0aNoFAoEBERgfPnz+P58+d6D96ZmZnhgw8+wPr167Fp0ya4uroavGcdP348xo8fD29vb7z33ntQqVQ4evQohBDZfi/dunVDy5Yt0a9fP1SoUAHHjx9HQEAAWrRokWWy7XXFrV1q7dq1CA4OxowZM7Bt2za0bNkStra2ePToEQICAnD//n1ERkbCwsICwKu5L1q3bo1BgwZh//798PDwwKVLl3D58mW0bdtWr0dLixYt0Lp1a/j5+aFly5Zo164dwsPDceDAAfj6+mLfvn069YuibWPHjh3o0KEDPvnkE+0xK5VK3L59G9euXdN7yMfY2BjDhw/HggULAHDS8CwJohyEhYUJAKJbt2465YMHDxYARFhYmN46c+fOFQCEv7+/TjkA0b59+yz3dfToUeHr6ysqVKggTExMhJOTk2jZsqVYsGCBiIiI0NbbtGmTACA2bdqU5bZUKpVYv369aN26tbC2thZmZmbCxcVFdO/eXaxbt04kJSW90bEIIcQff/whOnbsKGxsbISZmZlwc3MTAwcOFLdu3cp3LLkFQLi6uma53NXVVW95dseS3WfQvn17YejPRUEc1+vf5f79+0XTpk2FQqEQDg4OYsiQISIyMjLLdZOTk4WZmZlQKBTi5cuXOe4rK5cvXxbDhg0T7u7uQqFQaL/Ljz76SBw9elSv/vPnz8WECROEq6urMDExEeXLlxfvvfeeuHnzpl7d/HyuQhj+/jLrp6amihkzZoiqVasKU1NT4enpKVavXi00Go3edjIyMsTy5ctFvXr1hJmZmbCyshLt27cXBw4c0Kub3f8rf39/AUDMnTtXb9ndu3fF8OHDhaurqzA1NRV2dnaiXr16YsKECeLSpUvaepl/SwYPHmzwmA39fUhMTBQjR44UlSpVEkZGRlnGQEQklcy/bTm9Ms9TmX9rs3v99+9k5vk7u1fv3r3zHHvmecXQOUoIw+ew7M4H2Z1HsrsGye31X3YMfSYmJibCxcXF4LXZ68efncePH4uJEycKDw8PYWZmJqytrUWtWrXEiBEjxPHjx3XqBgYGiq5duwo7Ozvt+fbYsWMGP5fszolLliwRAESrVq1EQkKCtvzUqVOiXbt2QqFQCHt7e/H++++L8PDwLI8jKSlJzJkzR9SsWVOYmpoKW1tb4ePjI06fPp3l8bZq1UoAEFOnTtUpf/r0qfZzPX/+vN562X2/ubluJyIqSFm1YWTFzMxM794rPT1dfP3119q//y4uLmLq1KkiMTFR715t2bJlAoAYMWKE3raTkpK0f4evXr2qLTd071OQ945CCOHn5yeaN28uzMzMhIODgxg4cKB49uyZwW0VdFvBf7Vs2TLL7b/u3r17AoCoWbOmTnlu2l7y2q6T3TXNixcvxBdffCHq1q0rFAqFKFeunPDw8BAfffSR2Lt3r8HYz5w5oz1Xzp4922AdjUYjfvzxR1GnTh1hbm4unJycxPDhw0V0dHSO38uGDRtEnTp1hJmZmahUqZKYOHGiznVCpqza3Qqi/SbzMxs1alS29bL7PWVKSUkRS5cuFY0bNxaWlpZCoVCIatWqiT59+oitW7eKjIwMnfo3b94UPXr0EOXKlRNWVlbCx8dH3Lx5M8vvPSYmRgwaNEjY29sLhUIhWrRoIf75559sr0sKs21DCCGioqLExIkTRfXq1YWpqamwt7cXzZs3FytXrjS4nZCQEAFAVK5cWahUqiw/y7JMJkQR94cjIiogAQEBaNq0KQYOHKjt7lmadejQASdPnizybsxERERERERERMXNkCFDsGXLFoSFhWU5KX1JtWfPHrz//vuYM2dOliOZlHWcY4OISqxly5YBAMaMGSNxJERERERERERERG9OCIEVK1bA2NiYw1Blg3NsEFGJEhERgZ07d+L27dv47bfftGNNEhERERERERERlVQ3b97EX3/9hXPnzuHChQsYNWoUqlatKnVYxRYTG0RUooSGhmL27NkoV64cfH198dNPP0kdEhERERERERER0Ru5cuUKPvvsM9jY2GDgwIFYvny51CEVa5xjg4iIiIiIiIiIiIiISgzOsUFERERERERERERERCUGExtERERERERERERERFRicI4NAzQaDZ4+fQorKyvIZDKpwyEiItIjhEBiYiKcnZ0hl/M5BSIiIiLKHts6iIiouMtLWwcTGwY8ffqUM84TEVGJ8OjRI1SpUkXqMIiIiIiomGNbBxERlRS5aetgYsMAKysrAK8+QGtra4mjISIi0peQkICqVatqz1lERERERNlhWwcRERV3eWnrYGLDgMwumdbW1jzZExFRscZhBIiIiIgoN9jWQUREJUVu2jo4KDcRERERERERERGVKosWLULTpk1hZWUFR0dH9OnTB8HBwXr1zp8/j06dOsHS0hLW1tZo164dUlNTs9zuunXrUL9+fW2SsGXLlvj777+zjWXevHlo2LChXvnDhw8hk8kQGBiY18MjKvOY2CAiIiIiIiIiIqJS5eTJkxg7diwuXLiAo0ePIiMjA127dkVycrK2zvnz59G9e3d07doVly5dwuXLlzFu3LhsJy2uUqUKFi9ejCtXriAgIACdOnVC7969cfv27aI4LCL6fxyKioiIiIiIiIiIiEqVI0eO6LzfvHkzHB0dceXKFbRr1w4AMHnyZEyYMAGzZs3S1vP09Mx2u76+vjrvv/76a6xbtw4XLlxAnTp13ijmIUOGYMuWLXrl/v7+6NChwxttm6i0YY8NIiIiIiIiIiIiKtXi4+MBAPb29gCA6OhoXLx4EY6OjmjVqhUqVqyI9u3b48yZM7neplqtxu7du5GcnIyWLVu+cYzfffcdIiMjta+JEyfC0dERXl5eb7xtotKGPTaIiIiIiIiIiIio1NJoNJg0aRJat26NunXrAgBCQ0MBvJr/Yvny5WjYsCG2bt2Kzp0749atW/Dw8Mhyezdv3kTLli2hVCpRrlw57Nu3D7Vr1842hps3b6JcuXI6ZUIInfc2NjawsbEBAOzduxfr16/HsWPH4OTklOdjJirtmNggIiIiIiIiIiKiUmvs2LG4deuWTm8MjUYDABg1ahSGDh0KAPD29sbx48fxyy+/YNGiRVluz9PTE4GBgYiPj8eePXswePBgnDx5MtvkhqenJ/7880+dsidPnhgcYuratWsYOHAg1qxZg9atW+flUInKDCY2iIiIiIiIiIiIqFQaN24c/vrrL5w6dQpVqlTRlleqVAkA9JIRtWrVQkRERLbbNDU1hbu7OwCgcePGuHz5Mr777jusX78+V+tkMjbWb5qNiopCr169MGLECAwfPjz7gyMqwzjHBhEREREREREREZUqQgiMGzcO+/btg5+fH6pVq6az3M3NDc7OzggODtYpv3fvHlxdXfO0L41Gg7S0tDeOWalUonfv3vDy8sLKlSvfeHtEpRl7bBAREREREREREVGpMnbsWOzcuRMHDhyAlZUVoqKiALyax0KhUEAmk2H69OmYO3cuGjRogIYNG2LLli24e/cu9uzZo91O586d8c4772DcuHEAgNmzZ8PHxwcuLi5ITEzEzp07ceLECfzzzz9vHPOoUaPw6NEjHD9+HM+fP9eW29vbw9TU9I23T1SaMLFBREREREREREREpcq6desAQG8Oi02bNmHIkCEAgEmTJkGpVGLy5Ml48eIFGjRogKNHj6JGjRra+g8ePEBMTIz2fXR0NAYNGoTIyEjY2Nigfv36+Oeff/DWW2+9ccwnT55EZGSk3vBY/v7+BufiICrLZEIIIXUQxU1CQgJsbGwQHx8Pa2trqcMhIiLSw3MVEREREeUFrx+JiKi4y8u5inNsEBERERERERERERFRicHEBhERERERERERERERlRhMbBARERERERERERERUYnBxAYREREREREREREREZUYTGwQEREREREREREREVGJYSx1AFR0IiMjERkZmef1KlWqhEqVKhVCREREREREREREVJpFREQgJiZG6jAoH8qXLw8XFxepwyAyiImNMmT9+vWYP39+ntebO3cu5s2bV/ABERERERERERFRqRUREYFanp5IUSqlDoXywcLcHEHBwUxuULHExEYZMmrUKPTq1UunLDU1FW3atAEAnDlzBgqFQm899tYgIiIiIiIiIqK8iomJQYpSiTUNa8LDykLqcCgP7iemYFzgPcTExDCxQcUSExtliKEhpZKTk7X/btiwISwtLYs6LCIiIiIiIiIiKsU8rCxQ36ac1GEQUSnCycOJiIiIiIiIiIiIiKjEYGKDiIiIiIiIiIiIiIhKDCY2iIiIiIiIiIiIiIioxGBig4iIiIiIiIiIiIiISgwmNoiIiIiIiIiIiIiIqMQoVomNU6dOwdfXF87OzpDJZNi/f7/OcplMZvC1bNkybR03Nze95YsXLy7iIyEiIiIiIiIiIiIiosJQrBIbycnJaNCgAX744QeDyyMjI3Vev/zyC2QyGfr27atT76uvvtKpN378+KIIn4iIiIiIiIiIiIiICpmx1AG8zsfHBz4+Plkud3Jy0nl/4MABdOzYEdWrV9cpt7Ky0qtLREREREREREREREQlX7HqsZEXz549w6FDhzB8+HC9ZYsXL4aDgwO8vb2xbNkyqFSqbLeVlpaGhIQEnRcRERERERERERERERU/xarHRl5s2bIFVlZWePfdd3XKJ0yYgEaNGsHe3h7nzp3D7NmzERkZiZUrV2a5rUWLFmH+/PmFHTIREREREREREREREb2hEpvY+OWXXzBgwACYm5vrlE+ZMkX77/r168PU1BSjRo3CokWLYGZmZnBbs2fP1lkvISEBVatWLZzAiYiIiIiIiIiIiIgo30pkYuP06dMIDg7Gr7/+mmPd5s2bQ6VS4eHDh/D09DRYx8zMLMukBxERERERERERERERFR8lco6Nn3/+GY0bN0aDBg1yrBsYGAi5XA5HR8ciiIyIiIiIiIiIiIiIiApTseqxkZSUhJCQEO37sLAwBAYGwt7eHi4uLgBeDRP1+++/Y8WKFXrrnz9/HhcvXkTHjh1hZWWF8+fPY/Lkyfj4449hZ2dXZMdBRERERERERERERESFo1j12AgICIC3tze8vb0BvJovw9vbG19++aW2zu7duyGEQP/+/fXWNzMzw+7du9G+fXvUqVMHX3/9NSZPnoyffvqpyI6BiIiIiIiI3pybmxtWrVqV5fIOHTpg0qRJRRYPUWFatGgRmjZtCisrKzg6OqJPnz4IDg7WqdOhQwfIZDKd1+jRoyWKmIiISFrFKrHRoUMHCCH0Xps3b9bW+eSTT5CSkgIbGxu99Rs1aoQLFy4gLi4OqampuHPnDmbPns35M4iIiIiIiArQkCFDdBpXHRwc0L17d9y4cUPq0IhKpJMnT2Ls2LG4cOECjh49ioyMDHTt2hXJyck69UaOHInIyEjta+nSpRJFTEREJK1iNRQVERERERFRdoRSCU1KEkRyEjTJSRApyRAqFSAEoNG8qqTRAP//kBSEBhCAzMgIMDODzMwcMjMzyMwVkCssIbO0hExhAZm8WD3zVSJ0794dmzZtAgBERUXhiy++QM+ePRERESFxZEQlz5EjR3Teb968GY6Ojrhy5QratWunLbewsICTk1NRh0dERFTsMLFBRERERESSEkol1DHRUD9/9uoVEw3N82dQxzyHJikBIjkZmuREiJRkQKUq+ABksleJDmsbyO0dYGRfAXKH8q/+7VABcvvyMHIoD7lDBcjNFQW//xLKzMxM28Dq5OSEWbNmoW3btnj+/DkqVKiAmTNnYt++fXj8+DGcnJwwYMAAfPnllzAxMdFu4+DBg/jqq69w8+ZNlCtXDm3btsW+ffsM7m/jxo2YNm0a/vjjD3Tu3BkAoFKpMG7cOGzbtg0mJiYYM2YMvvrqK8hkMgDAy5cvMXHiRBw8eBBpaWlo3749Vq9eDQ8PDwCvGo8nTZqEX3/9FZMmTcKjR4/Qpk0bbNq0CZUqVdLZ94oVKxAWFgY3NzdMmDABn376aaF8rkQAEB8fDwCwt7fXKd+xYwe2b98OJycn+Pr6Ys6cObCwsDC4jbS0NKSlpWnfJyQkFF7ARERERYyJDSIiIiIiKnQiIx2qxxFQhYe+ej2OgDo6Curn0RCJ8RIHJyBSU6BOTYH6WSQysqkqK2cF4yquMK7iAuOqrjCq4grjKq4wqljpVa+QMiopKQnbt2+Hu7s7HBwcAABWVlbYvHkznJ2dcfPmTYwcORJWVlaYMWMGAODQoUN455138Pnnn2Pr1q1IT0/H4cOHDW5/6dKlWLp0Kf799180a9ZMW75lyxYMHz4cly5dQkBAAD755BO4uLhg5MiRAF4NmXX//n38+eefsLa2xsyZM9GjRw/cuXNHm2BJSUnB8uXLsW3bNsjlcnz88ceYNm0aduzYAeBVQ/KXX36JNWvWwNvbG9euXcPIkSNhaWmJwYMHF9pnSmWXRqPBpEmT0Lp1a9StW1db/tFHH8HV1RXOzs64ceMGZs6cieDgYOzdu9fgdhYtWoT58+cXVdhERERFSiaEEFIHUdwkJCTAxsYG8fHxsLa2ljqcQpWcnIxy5coBeHUzYmlpKXFERESUG2XpXEVEJYsQAuqnj6B6+AAZ4WFQRYRBFR4GdeRjQK2WOrzCY2IK40qVYVTVFcYu1WBasxZMataG3Fp/bsDSYMiQIdi+fTvMzc0BvLqvqFSpEv766y80atTI4DrLly/H7t27ERAQAABo1aoVqlevju3btxus7+bmhkmTJiEyMhLbtm3D0aNHUadOHe3yDh06IDo6Grdv39b20Jg1axb+/PNP3LlzB/fv30fNmjVx9uxZtGrVCgAQGxuLqlWrYsuWLXj//fexefNmDB06FCEhIahRowYAYO3atfjqq68QFRUFAHB3d8eCBQvQv39/7b4XLlyIw4cP49y5c2/yMRIZNGbMGPz99984c+YMqlSpkmU9Pz8/dO7cWef3+zpDPTaqVq3K60cqUlevXkXjxo3xT9uGqG9TTupwKA9uxCeh2+lAXLlyJctzO1FBy0tbB3tsEBERERFRvmmUqci4F4SMoJtID7qFjODbEEmJUodV9DLSXyVxIsKQdvYEMqf7NapUGSY1a796edaCSXUPyExMJQ21oHTs2BHr1q0D8GrIp7Vr18LHxweXLl2Cq6srfv31V6xevRoPHjxAUlISVCqVzg1qYGCgtmdFVlasWIHk5GQEBASgevXqestbtGihTWoAQMuWLbFixQqo1WoEBQXB2NgYzZs31y53cHCAp6cngoKCtGUWFhY6jcKVKlVCdHQ0gFcJmwcPHmD48OE6sapUKtjYlM6kFUlr3Lhx+Ouvv3Dq1KlskxoAtL/trBIbZmZmMDMzK5Q4iYiIpMbEBhERERER5Zo6Jhrpd25oExmqhw9Kd0+MN6SOfAJ15BMoTx59VWBsApPq7jDxqgvTBo1hWr9RiZ23w9LSEu7u7tr3GzduhI2NDTZs2IC3334bAwYMwPz589GtWzfY2Nhg9+7dWLFihba+QpHzcbdt2xaHDh3Cb7/9hlmzZhXKcbw+5wcAyGQyZA5skJSUBADYsGGDToIEAIzK8NBjVPCEEBg/fjz27duHEydOoFq1ajmuExgYCAA688EQERGVFUxsEBERERFRlkRGOtJvXUfalQtIu3IR6sfhUodUsqkyXvVwuReElD9/f5Xo8KoDM++mMGvYFMbunpDJ5VJHmS8ymQxyuRypqak4d+4cXF1d8fnnn2uXh4fr/nbq16+P48ePY+jQoVlus1mzZhg3bhy6d+8OY2NjTJs2TWf5xYsXdd5fuHABHh4eMDIyQq1ataBSqXDx4kWdoaiCg4NRu3btXB1TxYoV4ezsjNDQUAwYMCBX6xDlx9ixY7Fz504cOHAAVlZW2qHQbGxsoFAo8ODBA+zcuRM9evSAg4MDbty4gcmTJ6Ndu3aoX7++xNETEREVPSY2iIiIiIhIh+pZJNL/P5GRfuMqhDJV6pBKL1UGMm4FIuNWIJK2bYDMygZmDRrDtGETmDVpASOHClJHmKW0tDRt4+vLly+xZs0aJCUlwdfXFwkJCYiIiMDu3bvRtGlTHDp0CPv27dNZf+7cuejcuTNq1KiBfv36QaVS4fDhw5g5c6ZOvVatWuHw4cPw8fGBsbExJk2apF0WERGBKVOmYNSoUbh69Sq+//57ba8QDw8P9O7dGyNHjsT69ethZWWFWbNmoXLlyujdu3euj3P+/PmYMGECbGxs0L17d6SlpSEgIAAvX77ElClT8vnpEenKHNatQ4cOOuWbNm3CkCFDYGpqimPHjmHVqlVITk5G1apV0bdvX3zxxRcSREtERCQ9JjaIiIiIiAgZ94KQesYPaZfPs1eGhERiPJRn/KA84wfIZDDxqgPz1h1h3roDjMo7Sh2ejiNHjmiHwLGysoKXlxd+//13bcPs5MmTMW7cOKSlpeHtt9/GnDlzMG/ePO36HTp0wO+//44FCxZg8eLFsLa2Rrt27Qzuq02bNjh06BB69OgBIyMjjB8/HgAwaNAgpKamolmzZjAyMsLEiRPxySefaNfbtGkTJk6ciJ49eyI9PR3t2rXD4cOH9Yafys6IESNgYWGBZcuWYfr06bC0tES9evV0EixEbypz+LOsVK1aFSdPniyiaIiIiIo/mcjp7FkG5WX29ZIuOTkZ5cqVA/Bq/FhLS0uJIyIiotwoS+cqIio8GeFhUJ46BuXp41BHPpE6HMqOTAYTzzowb93hVZKjQkWpIyKiEobXjySFq1evonHjxvinbUPUtykndTiUBzfik9DtdCCuXLmCRo0aSR0OlRF5OVexxwYRERERURmiinwC5anjUJ4+DlV4qNThUG4JgYy7t5Bx9xYSf/kBJjVrw7xNB5i36wIj+/JSR0dEREREVKSY2CAiIiIiKuU0SYlI9f8HSv9/kXE/SOpw6E0JgYzg28gIvo3EzT/CrElLKLr2hFnjFpAZGUkdHRERERFRoWNig4iIiIiolEq/fQMp//wJ5dkTQHqa1OFQYVCrkXbxDNIunoHcoQIUXXpA8dbbMK5YSerIiIiIiIgKDRMbRERERESlkPL8KcR987nUYVAR0sQ+R/KvW5D821aYNmgCi26+MGveBrI8TJRNRERERFQSMLFBRERERFQKmTVpCbmNLTTxcVKHQkVNCKQHXkZ64GXIbe1h0fNdWPR4B3IrThZMRERERKWDXOoAiIiIiIio4MlMTKDo0kPqMEhimrgXSNq+Ec+HvYeE9auginoqdUhERERERG+MiQ0iIiIiolJK0b03IJNJHQYVA0KZipS//kDMqI8Qt3QuMkKCpQ6JiIiIiCjfmNggIiIiIiqljJ2cYerdVOowqDjRqKE87YfYySPw4vOJSAu4IHVERERERER5xsQGEREREVEpZtG9t9QhUDGVfuMqXs6fjpjJI5ngICIiIqIShYkNIiIiIqISTJWuRrD/I+z77Cwe34zRW27WrDXk5R0liIxKClXIXbycPx2xM8Yg7foVqcMhIiIiIsqRsdQBEBERERFR3iU8S0HQsQjcO/kYaUkZAIC7xyJQpV55nXoyIyNYdO2JpJ2/SBEmlSAZQbfw8otJMG3YBFaDR8PE3VPqkIiIiIiIDGJig4iIiIioBIkJi8e1/Q8QEfAMQuguC78ajeSXSljameuUK7r6IunXLYBaXYSRUkmVHhiA2OsjYd66I8oNHAlj5ypSh0REREREpIOJDSIiIiKiEiA6JA7X9obgUeDzLOsItUCw/yM0etdDp9zIoTzMmrVG2vlThR0mlRZCQHnGD8oLp2DR4x2UGzAccgtLqaMiIiIiIgLAOTaIiIiIiIq1qLsv8PeiS/jzy/PZJjUyBfs9hkYj9Mo5iTjli0qFlD9/R8yoj5DqdwTiv92EiIiIiIgkwB4bRERERETF0NPbsbi6NwRRQS/ytF7yCyUeXY2Ga5OKOuWm3k1hVKkK1JGPCzJMKiM0cS8Q/+3XSDnyJ6zHTIFJNXepQyIiIiKiMow9NoiIiIiIipHH15/j4LwLOPz1pTwnNTIFHY/QK5PJZLDo7vum4VEZlxF0E7GTRiDhx2+hSUqUOhwiIiIiKqOY2CAiIiIiKgai77/En3PP48iSADy79/KNtvXkRgwSo1P0yhWdewAmpm+0bSJo1Eg5tBcxoz9Cyr9/cXgqIiIiIipyTGwQEREREUko+YUS/j9cx5/zLiD6flyBbFMIIOj4I71yuY0tzFu3L5B9EGni45Dw/RK8/HwiVFFPpQ6HiIiIiMoQJjaIiIiIiCSgSlfj2t4Q/D71FB6cfQoU8EPv904+hlql0Su36N6nYHdEZV76zWuInTAEKX/vlzoUIiIiIiojmNggIiIiIipioRcisWfaaVzZcx+qNHWh7EOZkI6Hl6L0yk3r1Iexa/VC2SeVXSI1FQlrV+DFnClQP38mdThEREREVMoxsUFEREREVERiHsbjr68uwG91IJJiUgt9f0HH9CcRBwCFT+9C3zeVTemBlxEzbjBS/v1L6lCIiIiIqBRjYoOIiIiIqJClxqfh9IabOPD5OUTdfbOJwfMi6u5LvHycqFeu6NgNMnNFkcVBZYtISX4198b86VDHxkgdDhERERGVQkxsEBEREREVopAzT7Bn+mkE+z+GKOB5NHLD4CTiFpYwb9+l6IOhMiUt4AJixg+G8tJZqUMhIiIiolKGiQ0iIiIiokKQEp+Goyuv4sTaG0hLypAsjpDTTwzO42HRncNRUeETiQmIWzgbiZvWQqhVUodDRERERKUEExtERERERAXswbmn+GP6aYQHSD+JcnqKCg/OPdUrN3H3hEnNWhJERGWOEEjeuwsvZk+AOiZa6miIiIiIqBRgYqMYOnXqFHx9feHs7AyZTIb9+/dnWXf06NGQyWRYtWqVTvm9e/fQu3dvlC9fHtbW1mjTpg38/f1z3HdQUBB69eoFGxsbWFpaomnTpoiIMDzpJBERERHpSo1Pw7FVV+G/5rqkvTT+y9BwVAAnEaeilRF0EzEThyHtykWpQyEiIiKiEo6JjWIoOTkZDRo0wA8//JBtvX379uHChQtwdnbWW9azZ0+oVCr4+fnhypUraNCgAXr27ImoqKgstxcaGoo2bdrAy8sLJ06cwI0bNzBnzhyYm5u/8TERERERlXahFyLxx4zTeHhJ+l4a/xUTGo+Y0Hi9ckXbLpCVs5IgIiqrREI8Xs6fjsSt6yHU+kOkERERERHlBhMbxZCPjw8WLlyId955J8s6T548wfjx47Fjxw6YmJjoLIuJicH9+/cxa9Ys1K9fHx4eHli8eDFSUlJw69atLLc5f/589OjRA0uXLoW3tzdq1KiBXr16wdHRUVtHJpNh/fr16NmzJywsLFCrVi2cP38eISEh6NChAywtLdGqVSs8ePBAu87169fRsWNHWFlZwdraGo0bN0ZAQMAbfEJERERExYcyIR3Hv7sGv9WBUCYWn14a/3XnmH4vXJmZGRSduksQDZVpQiD59+148cUkqF++kDoaIiIiIiqBmNgogTQaDQYOHIjp06ejTp06essdHBzg6emJrVu3Ijk5GSqVCuvXr4ejoyMaN26c5Xb/+ecf1KxZE926dYOjoyOaN29ucBisBQsWYNCgQQgMDISXlxc++ugjjBo1CrNnz0ZAQACEEBg3bpy2/oABA1ClShVcvnwZV65cwaxZs/SSMUREREQl0eMbz7FnxmmEXcy6V2xxEXo+Eukp+okXTiJOUsm4FYjYaaOQ8fBBzpWJiIiIiF7DxEYJtGTJEhgbG2PChAkGl8tkMhw7dgzXrl2DlZUVzM3NsXLlShw5cgR2dnZZbjcpKQmLFy9G9+7d8e+//+Kdd97Bu+++i5MnT+rUGzp0KD744APUrFkTM2fOxMOHDzFgwAB069YNtWrVwsSJE3HixAlt/YiICHTp0gVeXl7w8PDA+++/jwYNGhTIZ0FEREQkBSEErv5xH/8sCYAyIV3qcHJFlabG/dNP9MqNq7rCtJ63BBERAZroKLyY8SnSAs5LHQoRERERlSBMbJQwV65cwXfffYfNmzdDJpMZrCOEwNixY+Ho6IjTp0/j0qVL6NOnD3x9fREZGZnt9nv37o3JkyejYcOGmDVrFnr27Ikff/xRp079+vW1/65YsSIAoF69ejplSqUSCQkJAIApU6ZgxIgR6NKlCxYvXqwzTBURERFRSaNMSsc/S6/g6h8hEELqaPLmLicRp2JIpKbg5YLZSP7zd6lDISIiIqISgomNEub06dOIjo6Gi4sLjI2NYWxsjPDwcEydOhVubm4AAD8/P/z111/YvXs3WrdujUaNGmHt2rVQKBTYsmVLlts2NjZG7dq1dcpq1aqFiAjd8ZhfH0YqM7liqEyj0QAA5s2bh9u3b+Ptt9+Gn58fateujX379uX/QyAiIiKSyPPQeOz/7BweX38udSj58vJxEqLu6s9pYN6yPeS29hJERPT/NGokbliN+LUrINQqqaMhIiIiomKOiY0SZuDAgbhx4wYCAwO1L2dnZ0yfPh3//PMPACAlJQUAIJfrfr1yuVybbDCkcePGCA4O1im7d+8eXF1d3zjumjVrYvLkyfj333/x7rvvYtOmTW+8TSIiIqKiFHQsAn/Nv4CkmFSpQ3kjQYYmETc2huKtHhJEQ6Qr9e/9eDl/BjTJSVKHQkRERETFmLHUAZC+pKQkhISEaN+HhYUhMDAQ9vb2cHFxgYODg059ExMTODk5wdPTEwDQsmVL2NnZYfDgwfjyyy+hUCiwYcMGhIWF4e2339au5+Xlhblz52rfT5w4EYMHD0a7du3QsWNHHDlyBAcPHtSZLyOvUlNTMX36dLz33nuoVq0aHj9+jMuXL6Nv37753iYRERFRUVKlqXHm51sIOfNU6lAKRNilKLRISIPC2kynXNGtF5L/2Alk8yAMUVFIv3YZsdNHw37echg5OkkdDhEREREVQ+yxUQwFBATA29sb3t6vJnGcMmUKvL298eWXX+Zq/fLly+PIkSNISkpCp06d0KRJE5w5cwYHDhzQmbQ7ODhYOw8GAPTq1Qs//vgjli5dinr16mHjxo34448/0KZNm3wfi5GREWJjYzFo0CDUrFkTH3zwAXx8fDB//vx8b5OIiIioqMRHJuPAl+dLTVIDADQqgXsnHuuVG1esBLNGzSSIiEif+lE4YmeOheqxfg8jIiIiIiKZEMVnysNTp05h2bJluHLlCiIjI7Fv3z706dNHu3zIkCF6c0R069YNR44c0b5/8eIFxo8fj4MHD0Iul6Nv37747rvvUK5cuVzHkZCQABsbG8THx8Pa2vqNj6s4S05O1n42SUlJsLS0lDgiIiLKjbJ0riKSyuObMTi+6hoyUkvfeP9Wjgp88G177dxomZSXziJuwSyJoiLSJ7e1g938FTCp7iF1KEQlHq8fSQpXr15F48aN8U/bhqhvk/u2OZLejfgkdDsdiCtXrqBRo0ZSh0NlRF7OVcWqx0ZycjIaNGiAH374Ics63bt3R2RkpPa1a9cuneUDBgzA7du3cfToUfz11184deoUPvnkk8IOnYiIiIhKkXunHuPfpQGlMqkBAInRqXhyI0av3KxJS8grVJQgIiLDNHEv8eKzCUi/e0vqUIiIiIioGClWc2z4+PjAx8cn2zpmZmZwcjI8zmpQUBCOHDmCy5cvo0mTJgCA77//Hj169MDy5cvh7Oxc4DETERERUelybX8Irvx2X+owCl3QsQhUaVBBp0wml8Oimy+Stm+UKCoifSI5CS/nTIHt59/ArGETqcMhIiIiomKgWPXYyI0TJ07A0dERnp6eGDNmDGJjY7XLzp8/D1tbW21SAwC6dOkCuVyOixcvZrnNtLQ0JCQk6LyIiIiIqGzRaATO/HyrTCQ1ACDi2nMkx6bqlSu69gSMjCSIiChrQpmKl1/NhPL8KalDISIiIqJioEQlNrp3746tW7fi+PHjWLJkCU6ePAkfHx+o1WoAQFRUFBwdHXXWMTY2hr29PaKiorLc7qJFi2BjY6N9Va1atVCPg4iIiIiKF1WaGsdWXsXd44+kDqXICI3AXX/9ScSN7Bxg1qKtBBER5SAjHXFLvkSq35Gc6xIRERFRqVaiEhv9+vVDr169UK9ePfTp0wd//fUXLl++jBMnTrzRdmfPno34+Hjt69GjsnNDS0RERFTWpSak4dDXFxFxNVrqUIpcsP8jaNQavXILn94SREOUC2o14r9bhNSTx6SOhIiIiIgkVKzm2Mir6tWro3z58ggJCUHnzp3h5OSE6GjdG1KVSoUXL15kOS8H8GreDjMzs0KLMyIiAjEx+pMzFgepqf8bfiAwMBAKhULCaLJXvnx5uLi4SB0GERERlSIJz5JxZHEAEp6lSB2KJFJepiHiajTcmupeK5vWbwyjylWhfsIHfqgY0mgQ/+1CyMzNYd68jdTREBEREZEESnRi4/Hjx4iNjUWlSpUAAC1btkRcXByuXLmCxo0bAwD8/Pyg0WjQvHlzSWKMiIiAZy0vKFP0xy8ubtq0Kd43BeYWCgQH3WVyg4iIiArE89B4/LM0AMqEdKlDkVTQsQi9xIZMJoNF915I/PkHiaIiyoFajbglc2E3ZzHMvJtKHQ0RERERFbFildhISkpCSEiI9n1YWBgCAwNhb28Pe3t7zJ8/H3379oWTkxMePHiAGTNmwN3dHd26dQMA1KpVC927d8fIkSPx448/IiMjA+PGjUO/fv3g7OwsyTHFxMRAmZKKqgu6w6yavSQxZEejVCF0xG8AgOobP4DcvFj9JLTSwl7g0ZwjiImJYWKDiIiI3lh0SBz+XnQZGakqqUOR3JNbsYiPSoaNk6VOuaJzDyRu2wCkl+3EDxVjGemI+/oz2M1fAdM69aWOhoiIiIiKULFqxQ4ICEDHjh2176dMmQIAGDx4MNatW4cbN25gy5YtiIuLg7OzM7p27YoFCxboDCO1Y8cOjBs3Dp07d4ZcLkffvn2xevXqIj+W/zKrZg8Lr4pSh6FHk5qh/beFpyPkChMJoyEiIiIqfDGh8TiymEkNLQHcPf4IzQd46RTLraxh3qYTlJyomYoxkabEy69mwH7hKph4eOW8AhERERGVCsUqsdGhQwcIIbJc/s8//+S4DXt7e+zcubMgwyIiIiKiUiLmYTz+XnQZ6SlMarzu/qnHaPKBB4xMjHTKLXx6M7FBxZ5IScaLuVNh/81qmLjVkDocIiIiIioCcqkDICIiIiIqCrHhCfj7m8tIS87IuXIZo0zMQNjFKL1yU6+6MK7mLkFERHkjEhPwcs4UqKKeSh0KERERERUBJjaIiIiIqNR7EZGIv7+5hLQkJjWyEnTskcFyC5/eRRwJUf5o4l7g5fwZ0CQlSh0KERERERUyJjaIiIiIqFR7+TgRh7+5BGUikxrZeXbvJV480m8QNm/fFTKFQoKIiPJO/TgccYu+gFBxuDkiIiKi0oyJDSIiIiIqtV4+ScLhry9BmZAudSglQtCxCL0yuYUFzDt0lSAaovxJv3EVCWuXSx0GERERERUiJjaIiIiIqFSKj0zG4a8vITWeSY3cCjnzFBlK/SfdLXz6FH0wRG8g9eghJP2+XeowiIiIiKiQMLFBRERERKVOSlwa/l50GalxaVKHUqJkpKrw4Kz+5Msm1dxh4lVXgoiI8i9p209Qnj0hdRhEREREVAiY2CAiIiKiUkWVpsbR5VeQFJMqdSglUtBxTiJOpYQQiFu5EOn37kgdCREREREVMCY2iIiIiKjUEBoB/x+u43lovNShlFixDxMQHRKnV27epiNkVtZFHxDRm0hPQ9yC2VDHREsdCREREREVICY2iIiIiKjUuLjjLsIDnkkdRolnaBJxmakZFJ19JIiG6M1o4l4gbvEciIwMqUMhIiIiogLCxAYRERERlQp3jobj1t8PpQ6jVAi9EIm0JP1GYIvuvQCZTIKIiN5MRvAdJG78XuowiIiIiKiAMLFBRERERCXeo2vROL8lSOowSg11ugb3Tz/WKzeu7ALT+o0kiIjozaUc3odU/3+kDoOIiIiICgATG0RERERUosWGJ8Dv+0AIjZA6lFKFk4hTaZTww3JkhIdJHQYRERERvSEmNoiIiIioxEp+ocQ/ywKQoVRLHUqpE/80GU/vxOqVm7VoC7m9gwQREb05kaZE3JI50ChTpQ6FiIiIiN4AExtEREREVCKp0tT4d1kAUl6kSR1KqWVwEnEjYyje6ilBNEQFQ/0oHAnrVkodBhERERG9ASY2iIiIiKhEOvPzLcSGJ0odRqkWfvkZUuL1E0cW3XwBuZEEEREVDKXfEaQcOyx1GERERESUT0xsEBEREVGJE3Q8AiFnnkodRqmnUQvc89efRNyoQkWYNWkhQUREBSfxp1VQRfHvCBEREVFJxMQGEREREZUoMaHxuLA1SOowyoy7/o8MTszOScSppBOpqYhf9Q2E0P99ExEREVHxxsQGEREREZUYaUkZOPbdNagzNFKHUmYkPU/F4+vP9cpNGzWHkWMlCSIiKjgZt68j5cBvUodBRERERHlkLHUARERERES5dWr9DSQ9T5U6jDLnzrEIVPV21CmTyeVQdPdF0tafJIqq+Fgd8giHI2MRkpQKcyM5mthZ4YtabnAvZwEAeJSiRDO/AIPr/tTIC77O5Q0uq/TXGYPlc2q54dMaVZCm1mDqjfv459kLOJqZYFFdd7SrYKutt/bBYzxJTcPXdWu82QGWconbfoJZ4xYwruoqdShUhi1atAh79+7F3bt3oVAo0KpVKyxZsgSenp7aOkqlElOnTsXu3buRlpaGbt26Ye3atahYsaKEkRMREUmDPTaIiIiIqES4/U84wq9ESx1GmfQ48DmSYvQTSoq3egLGfFbqfGw8hrpVwqE29fFrizpQCYF+F28jRaUGADgrzHC9SzOd1/SaLrA0MkInR7sst/vfdb5t4AEZgLedXiVCtkdE4UZ8Ev5qXR8fuzjh02vB2mGVIlKU2BERhVmebKzPUXo64ld9DaFWSx0JlWEnT57E2LFjceHCBRw9ehQZGRno2rUrkpOTtXUmT56MgwcP4vfff8fJkyfx9OlTvPvuuxJGTUREJB3ehRARERFRsRcbnoBLO+9KHUaZJQRw1+8RmnxQU6fcyNYO5i3bQXnaT6LIioddzevqvF/VoCbqHb2I6/FJaOlgAyOZDI7mpjp1/o6KRS/n8rA0Nspyu/9d50hULFo72MDV0hwAcD8pBd0qOsDTyhIuFub4KughYtNVKG9mgpk3Q/C5lxusTHjLlxsZ94KQvGcHyn04SOpQqIw6cuSIzvvNmzfD0dERV65cQbt27RAfH4+ff/4ZO3fuRKdOnQAAmzZtQq1atXDhwgW0aNFCirCJiIgkwx4bRERERFSsZShV8FsdyHk1JBZ84jE0av3vQOHTp+iDKeYSVSoAgF0WSYXrcUm4lZCM/lVzP3zM87R0HI9+if4u/1untrUlLr5IQKpajRPP41DRzBQOpsb443E0zORy9KhkeIgrMixp92ZkhIVIHQYRACA+Ph4AYG9vDwC4cuUKMjIy0KVLF20dLy8vuLi44Pz58wa3kZaWhoSEBJ0XERFRacHEBhEREREVa+e33EF8ZHLOFalQpcalITzgmV65WT1vGHFuAi2NEPjydiia2lnDy9rSYJ1dj6LgUU6BpvbWud7ub4+iUc7YCD2c/pes6F+1IupYW6L9iav47v4jrG/sibgMFZbdi8DXdWtg8d1wtPQLQL+LtxCZmvbGx1bqqTIQv3IhhFoldSRUxmk0GkyaNAmtW7dG3bqveoRFRUXB1NQUtra2OnUrVqyIqKgog9tZtGgRbGxstK+qVasWduhERERFhokNIiIiIiq2Iq5G497JJ1KHQf8v6Ngjg+UW3XsXcSTF1+xbD3A3MQU/NvI0uDxVrca+J8/xUR56awDArkfP8G7lCjA3+t8tnIlcjkX1auBS56Y40rYhmtvbYP6dMAx3q4Rb8Uk48iwWx9t5o7GtFb64HfpGx1VWqB4+QMrBPVKHQWXc2LFjcevWLezevfuNtjN79mzEx8drX48eGf4bTkREVBIxsUFERERExVJ6SgbO/nJb6jDoNU/vxBrsPaPo1B0wNZMgouLls5sPcOzZC/zRsh6cFYY/j78iY5Gq1uC9KrlPbFyIjceD5FR85JL9Omdj4hCcmIJh1ZxxLjYenSvYwcLYCL2cy+N8bHyejqUsS9q5CeoXMVKHQWXUuHHj8Ndff8Hf3x9VqlTRljs5OSE9PR1xcXE69Z89ewYnJyeD2zIzM4O1tbXOi4iIqLRgYoOIiIiIiqVLu4KR/EIpdRj0OgEEHYvQK5aXs4KiXWcJAioehBD47OYD/B0Vi99b1IOLhXmWdXdFRKFrRXuUNzPJ9fZ3PXqG+jblUMe6XJZ1lGoNZt96gKX13WEkk0EtBDKEAABkaATU//9vyplITUHizz9IHQaVMUIIjBs3Dvv27YOfnx+qVaums7xx48YwMTHB8ePHtWXBwcGIiIhAy5YtizpcIiIiyTGxQURERETFTmTQC9z145AZxdH900+gSlfrlSt8yu5wVLNvPcAfT6LxQyNPlDM2QrQyHdHKdKSqdT+nsORUXHiRgI9cDD9d3cb/Cg5H6vYUSMxQ4WBkTI69Nb69H4HOjvaoZ/Mq+dHM3hqHo2JxJyEZmx5G5mk+DwKUp44h7cZVqcOgMmTs2LHYvn07du7cCSsrK0RFRSEqKgqpqakAABsbGwwfPhxTpkyBv78/rly5gqFDh6Jly5Zo0aKFxNETEREVPWOpAyAiIiIiep0qXY3TG24CfMC8WEpLykDYhSh4tKusU25aszaMa9SE6sE9iSKTzpbwVxP39j1/U6d8VQMPfPjaXBq7Hj1DJXMzdKhga3A7D5JTkajSTYbsfxoDIYB3nCtkuf+7Cck4+DQGx9p5a8t6ViqPc7Hx6HPuBmpYKrA2izk/KGsJP65E+dWbITPmbTMVvnXr1gEAOnTooFO+adMmDBkyBADw7bffQi6Xo2/fvkhLS0O3bt2wdu3aIo6UiIioeOAVGhEREREVK1f/uI+EqBSpw6BsBB2L0EtsAICFT28krFkmQUTSiuzZJlf1PvNyw2debnnazkBXJwx0NdzDI5OXtSXOdWqiUyaXybC4njsW13PPVWykT/0oHMkHfkW5vgOkDoXKAJGL4eLMzc3xww8/4IcfOFQaERERh6IiIiIiomIjJjQeNw89lDoMykF0SBxiwxP0ys3bvwWZhaUEEREVjuTdW6COiZY6DCIiIiL6DyY2iIiIiKhY0Kg1OLXhJoSGY1CVBAYnETdXQNGxmwTREBUOoUxF4iYO9UNERERU3DCxQURERETFwvWDoXgRnih1GJRLD84+RXqqSq+8LE8iTqWT8rQfMkKCpQ6DiIiIiF7DxAYRERERSS4+KhmB+x5IHQblQYZSjQdnn+qVm7hWh0nt+hJERFRIhEDi1vVSR0FEREREr2Fig4iIiIgkd2lXMNQZGqnDoDwyNBwV8GoScaLSJP3aZaTduCp1GERERET0/5jYICIiIiJJRd19gfDLz6QOg/LhRUQint17qVdu3roDZNY2EkREVHiS2GuDiIiIqNhgYoOIiIiIJCOEwMUdd6UOg96AoV4bMhNTWHTpIUE0RIUnI/gOlOdPSR0GEREREYGJDSIiIiKSUOj5SDx/EC91GPQGwi5GQZmUrleu6N4bkMkkiIio8CRt2wChVksdBhEREVGZx8QGEREREUlCnaHG5V/vSR0GvSF1hgb3Tz7RKzeuVBmmDZtIEBFR4VE9eohU/yNSh0FERERU5jGxQURERESSuH0kHEnPU6UOgwrAXb9HEELolVv49Cn6YIgKWdKOXyBUKqnDICIiIirTmNggIiIioiKnTExH4IEHUodBBSQ+MhlPb8fqlZs1awW5QwUJIiIqPJqYaKSe+FfqMIiIiIjKNCY2iIiIiKjIXd0bgvQUPvFcmhicRNzIGIquPSWIhqhwpezdZbCXEhEREREVDSY2iIiIiKhIxUcm466BRnAq2cKvRCPlpVKv3KKbLyA3kiAiosKjevQQaZfPSR0GERERUZnFxAYRERERFamA3+5Bo+aTzqWNUAsEn3isV27kUAFmzVpJEBFR4Ures0PqEIiIiIjKLCY2iIiIiKjIxD1NwsNLUVKHQYXkrt8jaDSGJhHvLUE0RIUrI+gm0oNuSh0GERERUZlUrBIbp06dgq+vL5ydnSGTybB//37tsoyMDMycORP16tWDpaUlnJ2dMWjQIDx9+lRnG25ubpDJZDqvxYsXF/GREBEREZEhNw6GgsPSl17JsUo8uhatV27q3QxGTs4SRERUuJL/2Cl1CERERERlUrFKbCQnJ6NBgwb44Ycf9JalpKTg6tWrmDNnDq5evYq9e/ciODgYvXr10qv71VdfITIyUvsaP358UYRPRERERNlIjk1FyJmnOVekEi3o2CO9MplMBkV3/et2opIu7dJZqB49lDoMIiIiojLHWOoAXufj4wMfHx+Dy2xsbHD06FGdsjVr1qBZs2aIiIiAi4uLttzKygpOTk6FGisRERER5c3Nww85t0YZ8OTGcyQ+T4FVBQudcosubyNp+8+AKkOiyIgKgRBI3rsLNhNnSx0JERERUZlSrHps5FV8fDxkMhlsbW11yhcvXgwHBwd4e3tj2bJlUKlU0gRIRERERAAAZWI67vrpP8lPpY8QwN3j+t+13MYW5q07FH1ARIUs9dQxaBITpA6DiIiIqEwpsYkNpVKJmTNnon///rC2ttaWT5gwAbt374a/vz9GjRqFb775BjNmzMh2W2lpaUhISNB5EREREVHBuf1POFRpaqnDoCISfOIxNCqNXjknEadSKT0dqX5HpI6CiIiIqEwpkYmNjIwMfPDBBxBCYN26dTrLpkyZgg4dOqB+/foYPXo0VqxYge+//x5paWlZbm/RokWwsbHRvqpWrVrYh0BERERUZmQoVbjzb7jUYVARUiakI+zyM71y0zoNYOxaXYKIiApXyj9/Sh0CERERUZlS4hIbmUmN8PBwHD16VKe3hiHNmzeHSqXCw4cPs6wze/ZsxMfHa1+PHnGYBCIiIqKCctfvEdKSOK9CWRN0LMJgOScRp9JI/Sgc6bevSx0GERERUZlRohIbmUmN+/fv49ixY3BwcMhxncDAQMjlcjg6OmZZx8zMDNbW1jovIiIiInpzapUGtw4/lDoMkkBU0AvEPUnSK1d06g6ZuUKCiIgKV8oR9togIiIiKirFKrGRlJSEwMBABAYGAgDCwsIQGBiIiIgIZGRk4L333kNAQAB27NgBtVqNqKgoREVFIT09HQBw/vx5rFq1CtevX0doaCh27NiByZMn4+OPP4adnZ2ER0ZERERUNj048xTJL5RSh0ESCTqu32tDbmEJ83adJYiGqHApz53gJOJERERERaRYJTYCAgLg7e0Nb29vAK/my/D29saXX36JJ0+e4M8//8Tjx4/RsGFDVKpUSfs6d+4cgFc9L3bv3o327dujTp06+PrrrzF58mT89NNPUh4WERERUZl1J4vhiKhsuH/qCVTp+pPGW/j0KfpgiAobJxEnIiIiKjLGUgfwug4dOkAIkeXy7JYBQKNGjXDhwoWCDouIiIiI8iE2PAExofFSh0ESSk9RIfRcJGp2qKJTbuLuCROPWsi4HyRRZESFI/Wfg7Ds/YHUYRARERGVesWqxwYRERERlR7B/o+lDoGKgSwnEffpXcSREBU+1aOHSL97S+owiIiIiEq9YtVjg4iIiIhKB1W6Gg/OPpU6DCoGnofGIyYsHuWr2eiUK9p2RuLPayCS9ScYJyrJlKf9YOpVV+owqJBcv34dZ8+exZ07dxATEwOZTIby5cujVq1aaNWqFRo2bCh1iERERGUCExtEREREVOAeXopCWnKG1GFQMRF07BHajtRNbMjMzaHo1B0pB/dIFBVR4VCe8YfViPGQyWRSh0IFJDo6GmvXrsXWrVsRHh4OIQRMTU1hZ2cHIQTi4uKQnp4OmUwGFxcXDB48GGPGjEHFihWlDp2IiKjU4lBURERERFTggk9wGCr6nwfnniI9RT/RZcHhqKgU0ryIQcadG1KHQQVk5syZqF69On766Sf07NkT+/fvx+PHj6FUKhEZGYmoqCgolUo8fvwY+/fvR8+ePbFhwwbUqFEDs2fPljp8IiKiUos9NoiIiIioQMVHJSMy6IXUYVAxokpTI+TMU9Tu6qpTblzVDSZ1GyLjVqA0gREVEuVpP5jWaSB1GFQATp06he3bt6N3797Z9sJxdnaGs7MzfH19sXr1ahw4cABLly4twkiJiIjKFvbYICIiIqICde/EY0BIHQUVN0HHDU8izl4bVBopz52A0GikDoMKwPnz59GnT588DS0mk8nQp08fnDt3rhAjIyIiKtuY2CAiIiKiAqNRa3Dv1BOpw6Bi6OWjJETd1e/JY96yPeS2dhJERFR4NC9fIJ09kYiIiIgKDRMbRERERFRgIq4+R2pcmtRhUDEVdPyRXpnMxASKLj0kiIaocCnP+EkdAhWC6tWro2XLlggODja4/MCBA6hevXoRR0VERFT2MLFBRERERAXm/mn21qCsPbwUBWVCul65olsvQM5bEypd0s6dhFCrpQ6DCtjDhw9x9epVNGvWDPv379dbnpSUhPDw8KIPjIiIqIzh3QMRERERFQhVmhqPbzyXOgwqxtQZGtw7+Viv3NjJGabezSSIiKjwaOLjkHH3ltRhUCFYuXIl2rVrh759+2LOnDlSh0NERFQmMbFBRERERAXi0fXnUKdzslzK3l2/RxBCf3Z5TiJOpVHalYtSh0CFwM7ODgcPHsTcuXOxaNEivP3224iPj5c6LCIiojLFWOoAqOhkxCQhIyZZp0woVdp/pwZHQ2au/5MwKW8Jk/LlCj0+IiIiKtnCA55JHQKVAAnPUvDkZgyq1K+gU27WpCXk5R2hiYmWKDKigpd27RKsBn0idRhUSL788ks0a9YMH3/8MZo2bYp9+/ZJHRIREVGZwcRGGRL7x01Eb7iQ5fIHI34zWO44sgWcRrUsrLCIiIioFNCoNXh0jcNQUe4EHXukl9iQGRnBopsvknb8LFFURAVP9eAeNPEvIbexkzoUKiTdu3fH5cuX8e6776JFixbw8fGROiQiIqIygYmNMsShbz1Yt6+e5/VMylsWQjRERERUmkTeeYG05Aypw6ASIuJaNJJfKGFpb65TrujaE0m7NwOccJlKCyGQdi0Aig5vSR0JFaJq1arh/PnzGDVqFLZt2waZTCZ1SERERKUeExtliEn5chxSioiIiArFQw5DRXkg1ALB/o/QqK+HTrmRfXmYNW+DtHMnJYqMqOClXbvExEYp4u/vj1q1aumVm5ubY8uWLfjwww/x/Dl7MBIRERU2JjaIiIiI6I0IIRB+hYkNypu7/o/Q8B13yOW6TzZb+PRhYoNKlfRrlyCE4FP8pUT79u2zXd6jR48iioSIiKhsY2KDiIiIiN7I8wfxSHmRJnUYVMKkvEhDxJVouDWtqFNu2qAxjJyrQP30sUSRERUszcsXUD18AJNq7lKHQvl09erVPK/TqFGjQoiEiIiIMjGxQURERERvJJzDUFE+BR2L0EtsyGQyWHTvjcRffpAoKqKCl3blIhMbJViTJk1y3eMms3eOmnMFERERFSomNoiIiIjojTy8zMQG5c+TWzFIeJYC64oWOuWKzj5I3L4BSE+XKDKigpV+8xrw3gCpw6B82rRpk877xMRETJgwAdOnT0ft2rUlioqIiKhsY2KDiIiIiPIt4Vky4iOTpQ6DSioB3PWLQLP+XjrFcmsbmLfuCKX/PxIFRlSwMoJvc56NEmzw4ME672NjYzFhwgR069YNnTp1kigqIiKisk0udQBEREREVHJFBr2QOgQq4e6deAy1SqNXbuHTW4JoiAqHSE6CKiJM6jCIiIiISg0mNoiIiIgo36LuvpQ6BCrhlIkZCLsYpVduWqsejN1qSBARUeHIuHNT6hCIiIiISo18DUUVFxeHc+fO4c6dO4iJiYFMJkP58uVRq1YttGzZEnZ2dgUdJxEREREVQ1HssUEFIOhYBNxbO+uVW/j0RsK6lRJERFRwZFY2MPWsBbm9g9ShEBEREZUauU5spKenY+fOndi8eTPOnDkDjUa/uzgAyOVytG7dGkOHDkX//v1hZmZWYMESERERUfGRHJuKxOepUodBpcCz4Jd4+TgRdlWsdMrNO3RD4uZ1EKn8nVEJYWQEY9fqMPGsA1OvOjDxqgNj56pSR0VERERU6uQqsfHjjz9i4cKFiImJQdeuXfHtt9+icePGqF69Ouzs7CCEwMuXLxEWFoaAgAAcO3YMo0ePxhdffIE5c+Zg1KhRhX0cRERERFTEIjkMFRWgoGOP0GpIbZ0yuYUFzNt3ReqRAxJFRZQ9ua09TLzqvEpkeNaGiUctyMzNpQ6LCtiECRN03iuVSshkMqxZswb79+/Xqy+TyfDdd98VUXRERERlU64SG9988w2mTZuGoUOHwsbGxmCdSpUqoVKlSmjVqhUmTJiAhIQE/PLLL1i0aBETG0RERESlUNRdDkNFBef+6Sdo2q8mTMx1b1EsfHozsUHFg7EJTKq7w8SzjjaZYVyxUo6rJaVrcDtaiZvPXr2aVVFgQH0O31ySrFmzxmC5oaQGwMQGERFRUchVYiM0NBTGxnmbjsPa2hqTJk3CuHHj8hUYERERERVvTGxQQcpIVeHB+Uh4ddQdtsekugdMPGsjI/iORJFRWSUv7whTzzow8ar9KplRoyZkptkPtSyEQOjLdNx8psSt6DTceKZEeFw6NEK3HhMbJUtWQ3ETERGRdHKVrchrUqOg1iUiIiKi4ik1IQ1xT5KlDoNKmaCjEXqJDQCw8OmDeCY2qDCZmsKkhqfO3BhGDhVyXC1eqcataCVuPFPi1jMl7jxPQ1J69o3gd54rCypqIiIiojIrX1mHxMRExMXFoWrV/910PH36FD/++CPS0tLQt29fNGvWrMCCJCIiIqLiJYrza1AhiH2YgOcP4lChhq1OuXnbTkjY+D1EUqI0gVGpY+Tk/KoXhmdtmHrWgXF1D8hyeChPrREIeZHZG+PVsFIR8Rl53necUoPHCRmoYm2S3/CJiIiIyrx8JTY++eQThIWF4cKFCwCAhIQEtGjRAo8fP4ZcLsd3332HI0eOoEOHDgUZKxEREREVExyGigpL0PFHeokNmakZFJ19kHLgN2mCohJNZq6AiYeXdl4ME886MLLNeSio2BSVTm+MoOdpSFWJHNfLjaDnSiY2SojatWtj1qxZ6NevH0xNTXO1TlpaGnbu3Illy5bhzh32NiMiIioM+UpsnDlzRmdC8O3bt+Pp06c4d+4c6tSpg86dO2PhwoVMbBARERGVUtH34qQOgUqp0PORaD7AC2aWuo2+Fj69mdignMlkMHKu+qonhlcdmHjVhbFLNciMjLJdTaUWCI5N0+mN8TRRVWhhPniRjrdqFNrmqQANGTIEU6ZMwcSJE9GrVy906dIFjRo1QrVq1WBhYQEASE5ORlhYGAICAnDs2DEcPHgQpqammD59usTRExERlV75SmzExMSgcuXK2vd//vkn2rRpgxYtWgAABg0ahPnz5xdMhERERERUrAgh8PJJktRhUCmlSlPj/uknqNvdTafcuLILTOs3QvqNq9IERsWSzLIcTDxqwcSrzquJvj1rQ25lneN60ckq3Hz2v94YwTFpSFMXTG+M3Ah7mV5k+6I3M2PGDIwZMwY///wzNm/ejG3btkEmkwH435yiKtWrJJgQAnXr1sX8+fMxbNgwWFvn/FskIiKi/MlXYsPW1hZRUVEAgNTUVJw+fRqff/75/zZqbIyUlJSCiZCIiIiIipXE6BSo0tRSh0Gl2N3jEXqJDeDVJOJMbJRhcjmMq7rBxLO2dpJvo6pu2kbmrKSpNLgbo9sbIzpZ2r9hTGyULFZWVpg0aRImTZqEhw8f4ty5c7h79y5iY2MBAA4ODvDy8kLLli1RrVo1iaMlIiIqG/KV2GjVqhXWrl0LLy8vHDlyBEqlEr1799Yuv3fvnk6PDiIiIiIqPV4+Ym8NKlxxT5IRGRSLSrUcdMrNWrSF3M4empec46UskFnZwNSz9v/mxqhZC3ILyxzXe5KQoU1g3HymxL3YNKg0RRBwHjxKyIBKLWBslH1ShoofNzc3uLm5SR0GERFRmZevxMaSJUvQtWtX9O3bFwAwdepU1KlTBwCgVqvx+++/o3v37gUXJREREREVGy8eJ0odApUBQcce6SU2ZMbGULzVE8m/bZUoKio0RkYwdq2u7Ylh4lUHxs5Vc1wtNUODO8+VuPnsfz0yXqQW/x5lKg0QkZCB6na5m4yaiIiIiHTlK7Hh7u6O4OBg3LlzBzY2NjpPK6SkpGDNmjVo0KBBQcVIRERERMUIe2xQUXh4OQqp8WlQ2JjplFt064XkPdsBTTF7BJ/yRG5rr+2JYepZGyYetSAzN89xvfC4dJ0hpR68SEcRTo1RoMJephdYYmPIkCHYsmULgFdDQ9vb26N+/fro378/hgwZArlcnuttbd68GZMmTUJcXNwbx9WhQwecPHkSAGBmZobq1atj3Lhx+PTTT99420RERFS25SuxAQAmJiYGkxdWVlY6w1IRERERUenykj02qAhoVAL3Tj5Gg141dMqNHCvCrHELpF0+J1FklGfGJjCp7v5qOKn/T2YYV6yU42pJ6Rrcfm1IqdvPlYhXlp6EVujLdHQuwO11794dmzZtglqtxrNnz3DkyBFMnDgRe/bswZ9//qmd6LqojRw5El999RVSUlKwdetWjB07FnZ2dujfv79e3fT0dJiashcLERER5eyNrmwiIiIQGhqKly9fQgj9x2TefffdN9k8ERERERUzGpUG8U+TpQ6Dyoi7xx+hfs/qkMl15yFQ+PRmYqMYk5d3hKlnHZh41YaJV12Y1KgJmUn2jdVCCIS+zOyN8WpYqYdx6dCU0N4YuVHQE4ibmZnByckJAFC5cmU0atQILVq0QOfOnbF582aMGDECALBy5Ups2rQJoaGhsLe3h6+vL5YuXYpy5crhxIkTGDp0KABoJ2WfO3cu5s2bh23btuG7775DcHAwLC0t0alTJ6xatQqOjo7ZxmVhYaGNa968edi5cyf+/PNP9O/fHx06dEDdunVhbGyM7du3o169evD398etW7cwffp0nD59GpaWlujatSu+/fZblC9fHgC06wHAtm3bYGJigjFjxuCrr77KcTJ5IiIiKh3yldiIiIjAsGHD4O/vDwAGkxoymQxqdfEf25SIiIiIci8+KhmakjruC5U4ic9T8fhGDKo2rKBTbta4BeSOTtBER0kUGWmZmsKkhidMvOr8fzKjDowcKuS4WrxSrTPB953naUhKLz29MXLjYQEnNgzp1KkTGjRogL1792oTG3K5HKtXr0a1atUQGhqKTz/9FDNmzMDatWvRqlUrrFq1Cl9++SWCg4MBAOXKlQMAZGRkYMGCBfD09ER0dDSmTJmCIUOG4PDhw3mKSaFQID39f8e+ZcsWjBkzBmfPngUAxMXFoVOnThgxYgS+/fZbpKamYubMmfjggw/g5+ens97w4cNx6dIlBAQE4JNPPoGLiwtGjhz5Rp8ZERERlQz5SmwMHjwY58+fx6xZs9C8eXPY2NgUdFxEREREVAy94PwaVMSCjkfoJTZkcjksuvkiadsGiaIqu4ycnF8NKeVZG6ZedWFczR2yHIY4UmsEQl7ozo0REZ9RRBEXX0+TVEWyHy8vL9y4cUP7ftKkSdp/u7m5YeHChRg9ejTWrl0LU1NT2NjYQCaTaXtZZBo2bJj239WrV8fq1avRtGlTJCUlaZMf2VGr1di1axdu3LiBTz75RFvu4eGBpUuXat8vXLgQ3t7e+Oabb7Rlv/zyC6pWrYp79+6hZs2aAICqVavi22+/hUwmg6enJ27evIlvv/220BMbkZGRqFQp56HU8urUqVNYtmwZrly5gsjISOzbtw99+vTRLn99HpVM3bp1w5EjRwo8FiIiopIgX4mNCxcuYObMmZg/f35Bx0NERERExdjLR5xfg4rWo2vPkRSbinIOCp1yxVs9kbRrE6AqmsbhskimUMDEoxZMPGv/fzKjDoxs7XJc70WqStsT4+YzJYKepyFVxZ5e/5WcrkFimhpWZkaFuh8hhM7wTMeOHcOiRYtw9+5dJCQkQKVSQalUIiUlBRYWFllu58qVK5g3bx6uX7+Oly9fQqN51cMmIiICtWvXznK9tWvXYuPGjUhPT4eRkREmT56MMWPGaJc3btxYp/7169fh7+9vMFny4MEDbWKjRYsWOsfVsmVLrFixAmq1GkZGhfeZVq1aFZ06dcLAgQPx7rvvwtLSskC2m5ycjAYNGmDYsGFZDuudOY9KJjMzswLZNxERUUmUr8RGlSpVYGeX8wUtEREREZUucU/YY4OKltAIBPs9QuP3a+qUG9nZw7xFOyjP+GWxJuWJTAYj56ranhgmXnVg7FINshwaiFVqgeDYNJ3eGE8TmWzKragkVaEnNoKCglCtWjUAwMOHD9GzZ0+MGTMGX3/9Nezt7XHmzBkMHz4c6enpWSY2kpOT0a1bN3Tr1g07duxAhQoVEBERgW7duukMK2XIgAED8Pnnn0OhUKBSpUqQy+U6y/+bGEhKSoKvry+WLFmit63C6CmRV1999RV27tyJwYMHY8yYMejTpw8+/vhjdO3aVe/Y8sLHxwc+Pj7Z1nl9HhUiIqKyLl+JjWnTpmHNmjX45JNPsn2ig4iIiIhKl8TnqVKHQGVQsP9jeL/rDrmRbqOhwqc3Exv5JLMsB5OatWDi+f9zY3jWhtzKOsf1opNf9ca48UyJW8+UCI5JQxrn3cm3qCQVPBwK76l7Pz8/3Lx5E5MnTwbwqteFRqPBihUrtI3wv/32m846pqamevNl3r17F7GxsVi8eDGqVq0KAAgICMhVDDY2NnB3d891zI0aNcIff/wBNzc3GGczzNnFixd13l+4cAEeHh6F2lsDAD777DN89tlnuHbtGnbs2IHdu3dj586dcHR0RP/+/TFgwAA0adKkUPZ94sQJODo6ws7ODp06dcLChQvh4OBQKPsiIiIq7vKV2Bg1ahTUajU8PDzw3nvvoUqVKnoXDzKZTHvxRERERESlQ3IsExtU9FLi0hB+JRrVmuk+qWxWvxGMKrtA/SRCoshKCLkcxlXdXg0p5VUXpp61YVTVTWcYH0PSVBrcjdHtjRGdrM52HcqbZwU4z0ZaWhqioqKgVqvx7NkzHDlyBIsWLULPnj0xaNAgAIC7uzsyMjLw/fffw9fXF2fPnsWPP/6osx03NzckJSXh+PHjaNCgASwsLODi4gJTU1N8//33GD16NG7duoUFCxYUWOyvGzt2LDZs2ID+/ftjxowZsLe3R0hICHbv3o2NGzdq2x4iIiIwZcoUjBo1ClevXsX333+PFStWFEpMhnh7e8Pb2xvLli2Dn58fdu7ciU2bNmH16tXw9PTExx9/jI8//hguLi4Fsr/u3bvj3XffRbVq1fDgwQN89tln8PHxwfnz57NM5qSlpSEtLU37PiEhoUBiISIiKg7yldi4desWli5disjISHz//fcG6zCxQURERFS6qNLVUCZywl+SRtCxCL3EBgBY+PRG4kbD9yRllczKBqaetWHi9WpeDJOatSC3yHkegCcJGdoExs1nStyPTUOGRr9e9MkdeH5qF9JiHwMAFJU84Pz2ONjUbZ/jPl5c/guhP0+GbYMucB+zTlse9e9GRB19NRm8U9dP4PTWcO2ypLBAROyah1oz90BmlK9b2GIrJqXgEhtHjhxBpUqVYGxsDDs7OzRo0ACrV6/G4MGDtb0zGjRogJUrV2LJkiWYPXs22rVrh0WLFmkTHwDQqlUrjB49Gh9++CFiY2Mxd+5czJs3D5s3b8Znn32G1atXo1GjRli+fDl69epVYPFncnZ2xtmzZzFz5kx07doVaWlpcHV1Rffu3XWGeho0aBBSU1PRrFkzGBkZYeLEiTqTkhcVmUyGtm3bIi4uDk+ePMG///6L+/fvY968efjyyy/xzjvvYPXq1W88jFa/fv20/65Xrx7q16+PGjVq4MSJE+jcubPBdRYtWsS5UYmIqNTK11XhJ598gvj4eKxfvx7NmzeHjY1NgQRz6tQpLFu2DFeuXEFkZCT27duHPn36aJcLITB37lxs2LABcXFxaN26NdatWwcPDw9tnRcvXmD8+PE4ePAg5HI5+vbti++++87gxGNERFR0EhMTMWfOHOzbtw/R0dHw9vbGd999h6ZNm+rVHT16NNavX49vv/0WkyZNynKb69atw7p16/Dw4UMAQJ06dfDll1/mOD4xEeVPcqxS6hCoDHt6OxbxkcmwqaTbQK/o7IPErT8B6WlZrFnKGRnB2LX6qyGlvOq8mhvDuWqOq6VmaHDnuRI3n6VpkxkvUnPXG8PUzgmV+0yDuaMbAIGY8/sQsm4Man9+AApnjyzXS4t5jEd/LEY5d91helIe38XTg9/BfexPAATu//AJrGu3gUVlTwi1CuE7v4TbgIWlLqkBADEpBdMDZvPmzdi8eXOu6k6ePFnvIcSBAwfqvM+8xnpd//790b9/f50yIbIfhuzEiRP5Wu7h4YG9e/dmu66JiQlWrVqlF2dR8vf3x44dO/DHH38gISEB9erVw/LlyzFgwAAYGxtj06ZN+OabbzBw4EAcO3asQPddvXp1lC9fHiEhIVkmNmbPno0pU6Zo3yckJGiHEiMiIirp8nVlGBgYiPnz52PkyJEFGkxycjIaNGiAYcOG4d1339VbvnTpUqxevRpbtmxBtWrVMGfOHHTr1g137tyBubk5gFcTk0VGRuLo0aPIyMjA0KFD8cknn2Dnzp0FGisREeXNiBEjcOvWLWzbtg3Ozs7Yvn07unTpgjt37qBy5craevv27cOFCxfg7Oyc4zarVKmCxYsXw8PDA0IIbNmyBb1798a1a9dQp06dwjwcojIp+QUTGyQhAdz1e4TmA7x0iuXlrKBo2wmpx/+WKLCiJbezf9ULIzOR4e4F2f/fC2UnPC5dpzfGgxfpyO/UGLb1dRtRq/SZguendiIpLDDLxIbQqBH6y1Q4+05E0v3LUKcmapcpo0KhqOIJa6+WAACLyp5QRoXCorInoo5uhJV7U1i61c9fsMVcQfbYoKJx/fp17NixA7t27cLTp0/h5OSEESNGYNCgQahXr55O3WnTpsHc3BzTpk0r8DgeP36M2NjYbHuCmJmZwcys8OZwISIiklK+EhvVqlUr6DgAAD4+Plk+ZSuEwKpVq/DFF1+gd+/eAICtW7eiYsWK2L9/P/r164egoCAcOXIEly9f1k7W9f3336NHjx5Yvnx5rhrJiIio4KWmpuKPP/7AgQMH0K5dOwDAvHnzcPDgQaxbtw4LFy4EADx58gTjx4/HP//8g7fffjvH7fr6+uq8//rrr7Fu3TpcuHBBm9iQyWT48ccfcfDgQfj5+cHV1RW//PILKlSogBEjRuDy5cto0KABtm3bhho1agB4dcM6adIkBAQEQCaTwcPDA+vXry+0iSCJSgr22CCp3Tv5GI3f94Cxqe548gqf3qUzsWFsApPq7jDxqvtqfgzPOjCumPNwNknpGtz+/yTGrehXr3ilgTGlCoDQqPHyyt/QpKegXLWGWdZ7emgNTKwcUKH1+0i6f1lnmaJyTSifPUTai6eAEFBGP4TC2QPK5+GIOfcHan+2r1BiLw4KqscGFR1vb28oFAr06dMHgwYNwltvvaUzRNZ/1alTBy1btsxxu0lJSQgJCdG+DwsLQ2BgIOzt7WFvb4/58+ejb9++cHJywoMHDzBjxgy4u7ujW7duBXJcREREJU2+Ehvz58/HtGnT0K9fvyLrxhgWFoaoqCh06dJFW2ZjY4PmzZvj/Pnz6NevH86fPw9bW1udhqcuXbpALpfj4sWLeOedd4okViIi0qVSqaBWq7W96zIpFAqcOXMGAKDRaDBw4EBMnz49y94WkZGRiIyMNLhMrVbj2LFjSEpKgo2NDa5evapdNn/+fKxatQorV67EzJkz8dFHH6F69eqYPXs2XFxcMGzYMIwbNw5///2qUWzAgP9r787joqr3P46/Z9h3ZAcFQUDAfd9LXHI3t5tmmktmZVouLWY3cymzPbNyyUitm1n3l3Zts9JKb6aWmlsupamYO24IKgic3x9epyZAEYHD8no+HvOQ8z3fc+Y9w4DD+cz3+x2g+vXra/bs2XJwcNDmzZvl5ORUFE8FUKadP1tBp/pBqZGRdkn71h9V7E2V7dqd42rKsVqssn7/zaRkRcMaECTnuJpyir+8yLdTdHVZnJyveoxhGPr9dOb/ihiXF/refyZTOYUcjVFQ5w/t1q7n+yrnUoYcXNwVfe+sfEdrnNuzQSlr/q0aTyzLc79baIwq9xynX18dIkmq3PMhuYXGaPeMwarS+1Gd/eW/OvzZa7I4OCqi7xPyim1SXA+rxJ3LoLBRGNea4qo4vf322/rHP/5R4Omu27RpozZt2lyz34YNG+z6XZlCavDgwZo9e7a2bt2qhQsX6syZMwoLC1OHDh301FNPMSIDAFBhFaqwsXr1avn6+iouLk7t27dXeHi4HBzsPzVlsVj06quvFklISTp69KgkKTg42K49ODjYtu/o0aMKCgqy2+/o6Cg/Pz9bn7xkZGQoI+PPP9RTU1OLKjYAQJKXl5eaN2+up556SgkJCQoODtb777+vtWvXKiYmRpL03HPPydHRUQ8++GC+55k7d26BFkC87bbb7LZjYmLUt29fSdL48ePVvHlz23SGkjR69GgNHTrU1j85OVmPPPKI4uMvT3fy17WcgIrsAoUNlAI7VybnKmxIknvnnkp94wUTEhWSs7OcouPkFF/zf8WMmnLwD7zmYWcvZttNKbXjRIbSMotnNMbVuAZHqcY/lyn7wjmd3rRc+xc+qrhx7+UqbmRfTNO++Y8ocuA0OXn65Xu+oJvvUNDNd9i2U9YukYOLhzyr1df2SR2U8NgSZZ45qt/fGqvaT38jq1P5uJibbsL3DjdmyJAhxXLexMTEq65Z8uWXXxbL/QIAUFYVqrDx+uuv277+9NNP8+xT1IWN4jR9+vQCXSgDABTeu+++q7vuukuVK1eWg4ODGjRooP79+2vjxo3auHGjXn31VW3atEkWiyXfc9x777269dZb7dpSU1Ntn24bOHCgPv30U82bN0/VqlWTJDVs2FADBw609b9SIP/rHMjBwcG6ePGiUlNT5e3trXHjxunuu+/Wu+++q/bt2+u2226zTVMFVGQXzmaaHQHQ8V/P6GRyqvwjvO3aXVu317n5s2ScTzcp2dU5hIRdXhvjf4UMx6gYWRyv/udYdo6hPacybVNKbTt2UclnL5VQ4quzOjrLNaiqJMmjai2lH9imY98uVOSAp+36ZZxIVubJP/TbrHv/bDQuX8zfcH+8ak35Uq6BVe2OuZR2Soc/e03xDy1S+r4tcgmKkmtwpFyDI2VkX9LF4/vlXjmueB9gCUm/RGGjrJk5c6Y+++yzfAsNnTt31q233qoRI0aUcDIAACqWQhU2cnJK/s1XSEiIJOnYsWN2i2MdO3ZM9erVs/U5fvy43XFZWVk6deqU7fi8TJgwwTbMU7p8kaykptgCgIoiOjpaq1atUnp6ulJTUxUaGqp+/fqpWrVq+u9//6vjx48rIiLC1j87O1sPPfSQZsyYof3790uSQkNDcy2QmJ7+5wWsOXPmqEePHvr66681d+5cW/tfR/NdKZz8dWqpK21X/n+bPHmy7rjjDn322Wf64osvNGnSJC1evJgpDVHhXTjDiA2UDrtWHFTLu+ynLbS6ucstsYPOf27+egwWNzc5xSbY1sVwiqspB99K1zzu1IUs20iMbccuaueJDF3IKuY5pYqKkSPjUu7ip2tItGpO/Myu7dCyV5R9MV0RfZ+Qc6Xca4Yc/PczCm43VM6VQpW+f5uMnD+LOUZOtpRTfqZvysqRLmblyNUx/zUaULokJSWpbdu2+e6vUaOG3nzzTQobAAAUs0IVNswQFRWlkJAQrVy50lbISE1N1fr1621vGJo3b64zZ85o48aNatiwoSTpm2++UU5Ojpo2bZrvuV1cXJiXEgBKiIeHhzw8PHT69Gl9+eWXev7559WnTx+7NZQkqWPHjrrzzjvtpogqiJycHLvpBQurevXqql69usaOHav+/ftr/vz5FDZQ4V1IpbCB0mHPmkNqckecnFzt/5xx69yj5AsbFoscwsLlFFdDzvG15BRfU44RUbL8barev8vKNrT7ZIbdaIzD57JKKPSN+WPpi/KpdbOcK4UpOyNdp378ROd+Xa/YB96WJO2b/4icfINVpdfDsjq5yK1ydbvjHdy8JClXuySd3fG9Mo7tU9Tg5yVJHpG1dfHo7zq7fZUyTx+RxeIg1+BqxfwIS1Z6JoWNsmTv3r0aOXJkvvvj4+M1b968EkwEAEDFVKDCxvnz5+Xu7l6oO7ieY9PS0rRnzx7b9r59+7R582b5+fkpIiJCY8aM0dNPP63Y2FhFRUVp4sSJCgsLU8+ePSVJCQkJ6tSpk4YPH645c+bo0qVLGjVqlG6//XaFhYUVKj8AoGh8+eWXMgxDcXFx2rNnj20Ni6FDh8rJyUn+/v52/Z2cnBQSEqK4uD+nmmjXrp169eqlUaNGSbo84i4xMdG2f9KkSfruu+9uaA7iCxcu6JFHHtE//vEPRUVF6Y8//tBPP/2kPn36FPqcQHmRkV46psABLl3I1p41h5XQLsKu3SkyWk4JtXRp5/Ziu2+Lh6ecqifIKe5/a2PE1ZDVy/uaxx1Ptx+NsTslQxnZZWQ0xt9knTupffMf1aXU43Jw85Jb5XjFPvC2fGq0kiRlnDosXWVqyfzkZF5U8gdTFX33DFmsly/0O1cKVUS/J7XvncdkdXRW5JDnZHV2LdLHY7b0Sznyv3Y3lBLOzs5XXcPzyJEjslopVAEAUNwKVNgIDw/X6NGjNXz48FxTgOTn0KFDmjt3rmbNmqWUlJQCHbNhwwbbPOmSbNNDDR48WAsWLNCjjz6q9PR03XPPPTpz5oxatWql5cuXy9X1zze27733nkaNGqV27drJarWqT58+mjlzZoHuHwBQfM6ePasJEybojz/+kJ+fn/r06aNp06bZTQl1LXv37rX7P+X48eO65557bNsbN27Ul19+qVtuuaXQOR0cHHTy5EkNGjRIx44dU0BAgHr37s1aTICkbBa5RSmya0VyrsKGdHkR8bNFVdiwWuUYHnl5Sqn4WnKOqyGH8MirrgclSZnZhnaeuPiX0RgZOp5eNkZjFETkoOlX3R//0HtX3R815Pk8263Orqo95atc7YGt+iqwVd+CByxjWEC8bGnWrJkWLFigsWPHysvLy27f2bNnNX/+fDVr1sykdAAAVBwFKmzMnj1bkydP1tSpU9WyZUu1b99eDRo0UFRUlCpVqiTDMHT69Gnt27dPGzZs0IoVK7Ru3TrFxsZq1qxZBQ6TmJgow8j/U0sWi0VTp07V1KlT8+3j5+enRYsWFfg+AQAlo2/fvurbt+AXJa6sq3G1tqSkJKWnp8vT01OS9Omnn8rDw8Ouz9//X4mMjMzV9vf/f95///0C5wQqkqzM8jOvPcq+kwfO6fhvpxUUa792hWurNkqd95qMc2ev+5wWbx85V68hp/jL62I4VU+Q1d3jmscdSr1km05q27GL+u1khlgTGgVFYaNsmTRpklq3bq169eppzJgxqlnz8no/27dv14wZM3TkyBGuSQAAUAIKVNjo27ev/vGPf2jZsmVasGCBpk2bpszMzFyfVDIMQ87OzurQoYP+7//+T7feeitDMAEAAMqJbK7UopTZufJgrsKGxclZbu076/zSxVc/2MFBjlWrXV4XI+5yMcMxLPya93nhUo52nLg8CuNKMePUBYp+KLz0S2VzSrKKqmnTpvrkk0907733avTo0bbrIoZhKCoqSsuWLVPz5s1NTgkAQPlX4MXDrVarevbsqZ49eyojI0MbN27Url27dPLkSUmSv7+/4uPj1bBhQxbiBgAAKGeyL2VLXHtDKfP72iNqNjBBLp720xq6d+qh8x9/IP1lNJ61kt/lURhxNeUcX1NOMfGyuF57rYYDZzLtRmPsPZWpMro0BkqpS7ygypxbbrlFe/bs0c8//6y9e/dKkqKjo9WgQYNrTlUHAACKRoELG3/l4uKiFi1aqEWLFkWdBwAAAKVQFlOloBTKvpSjX1f/odpdouzaHcOqyL1LL8nBQU5xNeQcX0sOQSHXPF9aZo5+Of7n2hjbj1/U2Yu89lG8cq4yHTNKL6vVqoYNG6phw4ZmRwEAoEIqVGEDAAAAFUs262uglNq18mCuwoYked839qrHGYah309navvxDNtojP1nMpXDNWaUMF5yZdOOHTv0+++/6/Tp03muFTpo0CATUgEAUHFQ2AAAAMA1MWIDpdXZI+k6/MtJhdX0v3q/i9m2KaW2H7+oX45nKI3XNUoBimlly969ezVw4ED9+OOPeRY0JMlisVDYAACgmFHYAAAAwDVlX2LEBkqvnSuS8y1sXCloJJ+9JMOQvF0c1CLcQy3CPUo4JZC3+ADWqCxL7r33Xm3btk0zZszQTTfdpEqVKpkdCQCAConCBgDgmpKTk5WSkmJ2jDxduHDB9vXmzZvl5uZmYpqrCwgIUEREhNkxgELJ5pPtKMUObDim82cy5O6b+wKxj6uDWkZ4qKUJuQCUP2vWrNHjjz+uBx54wOwoAABUaBQ2AABXlZycrPj4BF24cN7sKNfUqlUrsyNclZubu3bt2klxA2VSFmtsoBTLyTa0+7uDqt8zxuwoAMq5gIAA+fj4mB0DAIAKj8IGAOCqUlJSdOHCeQ1r/ohCvcPNjpNLZlaGnl/5iCTp0XYvyNmxdE7ncCT1oJLWvqCUlBQKGyiTsrMYsYHSbdfKg3L3KZ3/BwBXVGseKidX/gwvy+677z7961//0siRI+Xg4GB2HAAAKqxCv6NKTk7WM888o2+//VYnTpzQxx9/rJtvvlkpKSmaOnWqhg4dqvr16xdlVgCAiUK9w1XVr/R9EjYj66Lt6wi/aLk4upqYBii/HBytZkcArir95EX9d952s2MAV1WlXiCFjTKuevXqys7OVt26dXXXXXcpPDw8zwJH7969TUgHAEDFUah3VDt27NBNN92knJwcNW3aVHv27FFWVpaky8Myv//+e6WnpyspKalIwwIAAMAcDs58KhUAbpTFajE7Am5Qv379bF8//PDDefaxWCzKzmYKRwAAilOhChuPPvqofH19tW7dOlksFgUFBdnt79q1qz744IMiCQgAAADzOTgxYgMAbpTVQmGjrPv222/NjgAAAFTIwsbq1av15JNPKjAwUCdPnsy1PyIiQocOHbrhcAAAACgdHJ0pbADADeNXaZnXunVrsyMAAAAVsrCRk5Mjd3f3fPefOHFCLi4s3AcAAFBeODgxFRUA3CgrU1GVGxkZGdq0aZOOHz+uli1bKiAgwOxIAABUKIX6vEiDBg302Wef5bkvKytLixcvVrNmzW4oGAAAAEoPB0ZsAMANszryu7Q8mDlzpkJDQ9WqVSv17t1bW7dulSSlpKQoICBAb7/9tskJAQAo/wr1rmrChAlavny5RowYoe3bt0uSjh07phUrVqhDhw7auXOnHnvssSINCgAAAPM4MmIDAG6Ig5NVjs78Li3r5s+frzFjxqhTp05KSkqSYRi2fQEBAWrbtq0WL15sYkIAACqGQk1F1blzZy1YsECjR4/Wm2++KUkaOHCgDMOQt7e33nnnHd18881FGhQAAADmYcQGANwYZw8nsyOgCLz00kvq0aOHFi1alOeaow0bNtTMmTNNSAYAQMVSqMKGJN15553q3bu3vvrqK+3Zs0c5OTmKjo5Wx44d5eXlVZQZAQAAYDKLxSKro0U5Wca1OwMAcnHxKPSf3yhF9uzZowcffDDf/X5+fnkWPAAAQNG6oXdWHh4e6tWrV1FlAQAAQCnm6OygzKwss2MAQJnk4uFsdgQUAV9fX6WkpOS7f8eOHQoJCSnBRAAAVEw3VNi4dOmSDh06pNOnT9vNK3lFgwYNbuT0AADYOXPhlM5eOGXXdik7w/b1wdN75eTgkus4Hzc/+br5FXs+oLxzcHaQzlPYAIDCcGbERrnQpUsXvfnmm7r//vtz7fvll180b9483XXXXSYkAwCgYinUO6szZ87o4Ycf1nvvvafMzMxc+w3DkMViUXZ29g0HBADgitV7Ptcn2xflu/+5FY/k2d691h26tfbA4ooFVBguHo66cCbj2h0BALm4ejJiozx4+umn1bRpU9WqVUvdu3eXxWLRwoUL9fbbb+ujjz5SaGionnzySbNjAgBQ7hWqsDFkyBB98sknuv3229W0aVP5+PgUdS4AAHK5OaaL6lZudt3H+TBaAygS7r6uOnMo3ewYAFAmMWKjfAgLC9PGjRv1+OOP64MPPpBhGHr33Xfl5eWl/v3769lnn1VAQIDZMQEAKPcK9c7qq6++0oMPPqhXXnmlqPMAAJAvX6aUAkzlXin3VG8AgIJx8XQyOwKKSFBQkN566y299dZbOnHihHJychQYGCir1Wp2NAAAKoxCFTb8/f0VExNT1FkAAABQirlXcjU7AgCUWS4eFDbKo8DAQLMjAABQIRWqsHHPPfdo8eLFGjFiBJ9IAAAAqCDcfRmxAQCF5Uxho1yYOnXqNftYLBZNnDixBNIAAFBxFaqwMXHiRGVkZKhRo0a68847VaVKFTk4OOTq17t37xsOCAAAgNKBqagAoPBcKWyUC5MnT853n8VikWEYFDYAACgBhSpsHDp0SN988402b96szZs359nHYrEoOzv7RrIBAACgFGEqKgAoPI8AN7MjoAjk5OTk2XbgwAG98cYbWr16tb744gsTkgEAULEUqrBx1113adOmTZowYYKaNm0qHx+fos4FAACAUsaDERsAUGjeQe5mR0AxsVqtioqK0osvvqgBAwbogQce0KJFi8yOBQBAuVaowsb333+v8ePHa8qUKUWdBwAAAKUUU1EBQOG4+7rI0SX39M0of26++WaNHz/e7BgAAJR7hVr5OyQkRH5+fkWdBQAAAKWYg5ODXDyZIx4ArpcXozUqjA0bNshqLdSlFgAAcB0KNWLjoYce0uzZszVs2DB5enoWdSYAAACUUu6+LspIu2R2DAAoU7yDKWyUF++8806e7WfOnNHq1au1ZMkS3X333SWcCgCAiqdQhY2LFy/KyclJMTEx6tu3r8LDw+XgYD+s1mKxaOzYsUUSEgAAAKWDZ6CbTv+RZnYMAChTvIJZOLy8GDJkSL77AgIC9Nhjj+nJJ58suUAAAFRQhSpsPPzww7avX3/99Tz7UNgAAAAof3wre+rgzyfMjgEAZQoLh5cf+/bty9VmsVhUqVIleXl5mZAIAICKqVCFjbz+IwcAAED5V6kK05ACwPViKqryo2rVqmZHAAAAKmRhg//IAQAAKia/KnwaFQCulxeFDQAAgCJVqMIGAAAAKibfyp6SRZJhdhIAKBuc3Bzk5u1idgwUEavVKovFcl3HWCwWZWVlFVMiAAAqpgIVNqKiomS1WrVr1y45OTkpKirqmv+RWywW7d27t0hCAgAAoHRwdHGQV6Cbzh2/YHYUACgTWF+jfHnyySf18ccf65dfflHHjh0VFxcnSdq1a5e++uor1apVSz179jQ3JAAAFUCBChutW7eWxWKR1Wq12wYAAEDFUynci8IGABSQb2XWJipPwsLCdPz4cW3fvt1W1Lhi586datu2rcLCwjR8+HCTEgIAUDEUqLCxYMECrV69WqdOnVJgYKAWLFhQzLEAAABQWlWq7KnkjcfNjgEAZUJANR+zI6AIvfDCCxo1alSuooYkJSQkaNSoUXr++ecpbABAGbJ69Wq98MIL2rhxo44cOaKlS5fmGn1nGIYmTZqkefPm6cyZM2rZsqVmz56t2NjYq5770KFDGj9+vL744gudP39eMTExmj9/vho1apRn/wULFmjMmDE6c+ZMrn0WiyXPbBWVtaAd27Rpo6+//ro4swAAAKAMqBTOAuIAUFCBFDbKlT/++ENOTk757ndyctIff/xRgokAADcqPT1ddevW1RtvvJFvn+eff14zZ87UnDlztH79enl4eKhjx466ePFivsecPn1aLVu2lJOTk7744gvt2LFDL730kipVqlQcD6PCKXBhwzBYIRIAAABSpSpMqwIABWGxWuQf6W12DBShWrVqadasWTp06FCufX/88YdmzZql2rVrm5AMAFBYnTt31tNPP61evXrlud8wDM2YMUNPPPGEevTooTp16uidd97R4cOH9fHHH+d73ueee07h4eGaP3++mjRpoqioKHXo0EHR0dE3nHny5MmyWCy5bhVppqUCFzYAAAAASfIN85DFynprAHAtvpU95ORaoBmgUUa88sorOn78uKpXr66BAwdq8uTJmjx5sgYMGKC4uDgdP35cL7/8stkxAQBFaN++fTp69Kjat29va/Px8VHTpk21du3afI9btmyZGjVqpNtuu01BQUGqX7++5s2bVySZHn74YR05csR2e/HFF+Xu7p7vFFfl0XW9w2LBcAAAADg4Ocgn1F1nDqWbHQUASjWmoSp/WrVqpfXr12vixIlaunSpLly4IElyc3NTx44dNWXKFEZsAEA5c/ToUUlScHCwXXtwcLBtX15+//13zZ49W+PGjdPjjz+un376SQ8++KCcnZ01ePDgfI87e/asPD2vPkre09PT1mfdunV64okntHDhQtWqVaugD6vMu67CxsCBAzVw4MAC9bVYLMrKyipUKAAAAJRuwdUrUdgAgGtg4fDyqVatWlq6dKlycnJ04sQJSVJgYKCsVibFAAD8KScnR40aNdIzzzwjSapfv762b9+uOXPmXLWw4eXlpU2bNuVqz2uh8uTkZPXs2VMPP/yw+vbtW3Thy4DrKmy0b99e1atXL64sAAAAKCNC4vy0+1sWRwWAq2HERvlmtVrl6uoqT09PihoAUI6FhIRIko4dO6bQ0FBb+7Fjx1SvXr18jwsNDVWNGjXs2hISEvTRRx9d9f6sVqtiYmKumSs9PV233nqrmjdvrqlTp16zf3lzXYWNwYMH64477iiuLAUSGRmpAwcO5Gq///779cYbbygxMVGrVq2y23fvvfdqzpw5JRURAACg3AtJqGR2BAAo1ayOFvlVZeHw8mjDhg164okntHr1amVmZuqrr75S27ZtlZKSomHDhmns2LFKTEw0OyYAoIhERUUpJCREK1eutBUyUlNTtX79eo0YMSLf41q2bKndu3fbtf3666+qWrXqDWcyDEMDBw5UTk6O3n333Qq5hESZ+0jBTz/9ZLcwytdffy1Juu2222x9hg8fbtfn+eefNysuAABAueQV6C4Pf1ezYwBAqeUX7iUHxzL3Jzeu4YcfflCrVq3022+/2S4oXREQEKCzZ89q7ty5JiYEAFyvtLQ0bd68WZs3b5Z0ebHwzZs3Kzk5WdLlJRfGjBmjp59+WsuWLdO2bds0aNAghYWFqWfPnrbztGvXTq+//rpte+zYsVq3bp2eeeYZ7dmzR4sWLdKbb76pkSNH3nDmyZMna8WKFZo7d67S0tJ09OhRHT161Lb2U0VwXSM2SoPAwEC77WeffVbR0dFq3bq1rc3d3d02RAgAAADFIySukvb+cMTsGABQKrG+Rvn0+OOPKyEhQevWrdO5c+f01ltv2e1v06aNFi5caFI6AEBhbNiwQW3atLFtjxs3TtLl2YsWLFggSXr00UeVnp6ue+65R2fOnFGrVq20fPlyubr++WGvvXv3KiUlxbbduHFjLV26VBMmTNDUqVMVFRWlGTNmaMCAATecedWqVUpLS1OLFi3s2ufPn68hQ4bc8PnLgjJX2PirzMxM/etf/9K4cePshtu89957+te//qWQkBB1795dEydOlLu7u4lJAQAAyp+QeD8KGwCQj+BYpuwrj3766SdNnz5dLi4uSktLy7W/cuXKOnr0qAnJAACFlZiYKMMwrtrHYrFo6tSpV13LYv/+/bnaunXrpm7duhU4y5AhQ/ItTPw143fffVfgc5ZXBS5s/HV4ZWnx8ccf68yZM3bf7DvuuENVq1ZVWFiYtm7dqvHjx2v37t1asmRJvufJyMhQRkaGbTs1NbU4YwMAAJQLIfFctAOA/FSu7W92BBQDJyenq14fOXTokDw9PUswEQAAFVOZHrGRlJSkzp07KywszNZ2zz332L6uXbu2QkND1a5dO+3du1fR0dF5nmf69OmaMmVKsecFAAAoT3wre8rF00kZaZfMjgIApYpfhJfcK7EOUXnUrFkz/d///Z/GjBmTa196errmz59vN1U2AAAoHmV2JbMDBw5oxYoVuvvuu6/ar2nTppKkPXv25NtnwoQJOnv2rO128ODBIs0KAABQHlksFoXEMWoDAP6ucp0AsyOgmEyZMkUbNmxQ165d9cUXX0iStmzZorfeeksNGzbUiRMnNHHiRJNTAgBQ/pXZERvz589XUFCQunbtetV+V1azDw0NzbePi4uLXFxcijIeAABAhRAS76cDG4+bHQMASpUqFDbKraZNm+rzzz/XiBEjNGjQIEnSQw89JEmKjo7W559/rjp16pgZEQCACqFMFjZycnI0f/58DR48WI6Ofz6EvXv3atGiRerSpYv8/f21detWjR07VjfffDNvLAAAAIpBaIKf2REAoFRxdHFgNFs5ZRiGzp07pxYtWmj37t3avHmzfvvtN+Xk5Cg6OloNGzaUxWIxOyYAABVCmSxsrFixQsnJybrrrrvs2p2dnbVixQrNmDFD6enpCg8PV58+ffTEE0+YlBQAAKB884/ylnslF50/nWF2FAAoFUIT/OTg5GB2DBSDzMxM+fn56ZlnntGjjz6qevXqqV69embHAoByIzk5WSkpKWbHQCEEBAQoIiKiRO+zTBY2OnToIMMwcrWHh4dr1apVJiQCAAComCwWiyIaBGnXStYoAwCJ9TXKMxcXF4WEhDCVNQAUg+TkZMXHJ+jChfNmR0EhuLm5a9eunSVa3CiThQ0AAACUHpGNgilsAMD/sL5G+TZkyBC98847GjFihJydnc2OAwDlRkpKii5cOK9hzR9RqHe42XFwHY6kHlTS2heUkpJCYQMAAABlR1hNfzm7OyrzfJbZUQDAVJ4BbvIN8zQ7BopR7dq19fHHH6tmzZoaMmSIIiMj5ebmlqtf7969TUgHAGVfqHe4qvrFmB0DZQCFDQAAANwQq6NVVeoG6ve1R8yOAgCmYrRG+de/f3/b1xMnTsyzj8ViUXZ2dklFAgCgQqKwAQAAgBtWtVEwhQ0AFV54/UCzI6CYffvtt2ZHAAAAorABAACAIhBeL1BWR4tysgyzowCAKVw8nRRel8JGefT444/r9ttvV506ddS6detiuY/Vq1frhRde0MaNG3XkyBEtXbpUPXv2tO03DEOTJk3SvHnzdObMGbVs2VKzZ89WbGxsseQBAKC0s5odAAAAAGWfs5ujwmr6mx0DAEwT2ThEVkf+xC6Pnn32WW3fvt22ffLkSTk4OOibb74psvtIT09X3bp19cYbb+S5//nnn9fMmTM1Z84crV+/Xh4eHurYsaMuXrxYZBkAAChLGLEBAACAIlG1UbD+2JJidgwAMEV0i1CzI6AEGUbRjlDs3LmzOnfunO99zZgxQ0888YR69OghSXrnnXcUHBysjz/+WLfffnuRZgEAoCzg4yQAAAAoElUbBksWs1MAQMlz93NRaIKf2TFQTu3bt09Hjx5V+/btbW0+Pj5q2rSp1q5dm+9xGRkZSk1NtbsBAFBeUNgAAABAkXD3dVFwbCWzYwBAiavWLFQWK5VdFI+jR49KkoKDg+3ag4ODbfvyMn36dPn4+Nhu4eHhxZoTAICSxFRUAAAAKDLVW1fWsV9Pmx0DAEpUTIswsyOgmO3fv1+bNm2SJJ09e1aS9Ntvv8nX1zfP/g0aNCipaPmaMGGCxo0bZ9tOTU2luAEAKDcobAAAAKDIVGseqnXv7tSli9lmRwGAEuET6qGAaj5mx0AxmzhxoiZOnGjXdv/99+fqZxiGLBaLsrOL7v/BkJAQSdKxY8cUGvrnWi7Hjh1TvXr18j3OxcVFLi4uRZYDAIDShMIGAAAAioyTq6OimoXq1+/+MDsKAJQIFg0v/+bPn2/q/UdFRSkkJEQrV660FTJSU1O1fv16jRgxwtRsAACYhcIGAAAAilRcYhUKGwAqjGimoSr3Bg8eXOz3kZaWpj179ti29+3bp82bN8vPz08REREaM2aMnn76acXGxioqKkoTJ05UWFiYevbsWezZAAAojShsAAAAoEgFV68k38qeOnMozewoAFCsAqr5yCfUw+wYKAc2bNigNm3a2LavrI0xePBgLViwQI8++qjS09N1zz336MyZM2rVqpWWL18uV1dXsyIDAGAqChsAAAAocnGJVbT+vV1mxwCAYhXXporZEVBOJCYmyjCMfPdbLBZNnTpVU6dOLcFUAACUXlazAwAAAKD8ib2psqyOFrNjAECxcXZ3VGyrymbHAAAAqJAobAAAAKDIuXo7q2qDYLNjAECxiWsTLkcXB7NjAAAAVEgUNgAAAFAsmKIFQHllsUg1OkSYHQMAAKDCorABAACAYlG5doA8A1jUFED5E9EgSF6B7mbHAAAAqLAobAAAAKBYWKwWxbflE80Ayp+anSLNjgAAAFChUdgAAABAsYlvzxz0AMqXSlU8FVbT3+wYAAAAFRqFDQAAABQbV09nVW/NWhsAyo8aHauaHQEAAKDCo7ABAACAYlW7S6QsVovZMQDghrl4OCm2VWWzYwAAAFR4FDYAAABQrLyC3BXZONjsGABww6onVmF6PQAAgFKAwgYAAACKXZ3u1cyOAAA3xOJgUY0OEWbHAAAAgChsAAAAoAQEVvNR5doBZscAgEKrfnNleQW6mx0DAAAAorABAACAElKvZ7TZEQCgUKyOFtXvFWN2DAAAAPwPhQ0AAACUiNAEP4XEVzI7BgBct7g24fIMcDM7BgAAAP6HwgYAAABKTL0ejNoAULY4OFkZcQYAAFDKUNgAAABAialSN1CB0T5mxwCAAktoHyGPSq5mxwAAAMBfUNgAAABAiWpyR5zZEQCgQBxdHFTn1mpmxwAAAMDfOJodAAAAABVLaIK/IhoGKXnjcbOjlGqnz6foo83ztf3IBmVmZyjIM1RDmo5VpH91SdLFSxe0ZMt8/fzHWqVnnlOAR7DaVr9VibFdr3reFbs+1nd7PtOp8yfk6eKthuGt1LvuEDk5OEuS1u3/Vku2zFfGpYtqUa29+jW4x3ZsStoxvfLdP/VEx5lyc3IvvgcPlBI1OkTI3cfF7BgAAAD4GwobAAAAKHFN+sfp4OYTMrINs6OUSumZ5/TciocVF1RHoxOnytPFR8fPHZa7s5etz4c/z9OuY1t0d/NH5O8RrB1HN+m9DW/I181f9ao0y/O86/d/q4+2zNeQpmMUHVBDx84d0vz1L0uS+jW4R+cyzuqdH1/V0KZjFeAZqtdWTVJ8cF3VrdxUkvTehjfUp+5QihqoEJzcHFSnG6M1AAAASiMKGwAAAChxvmGeim8brp1fJ5sdpVRavuP/VMk9UEObjbO1BXqG2PXZm7JTLaLaKS64jiTp5pjOWrXnC+07tTvfwsbelJ2KCayhppFtJEkBnsFqEtFa+07uliSlpB2Vm5OHGldtLUmKC66jo6kHVbdyU63f/50crI5qEN6yyB8vUBrV7BgpVy9ns2MAAAAgD6yxAQAAAFM06BMjJzc+Z5OXLYfWKdIvVnO+f0bjlvTX1C9GafWe5XZ9ogMStPnQep0+nyLDMLTr2BYdO3dINUMa5Hve6IAEHTi1x1bIOJF2RNuObFCtsMaSpCCvMGVmXVTyqb1Kzzin/Sd/U2XfKKVnntN/tr2rOxqOKL4HDZQizu6Oqt0lyuwYAAAAyAd/SQIAAMAUbt4uqntrNW344Fezo5Q6J9KO6rvfPtMt8b3UpUY/7T/1qxZvmiNHq6NaVGsvSerfcITe/XGmHv3PIDlYHGSxWHRnk9GqHlQ73/M2jWyjtIxUPbfiEckwlG1kq3VMF3Wt2U+S5OHspaHNHtLb615UZnammke1Va3QhlqwfobaxnZXSvpRvb56irKNbN1aa4AaRrQqkecDKGkN+sTIxdPJ7BgAAADIB4UNAAAAmKZW50jtXJGs9JMXzY5SqhgyFOkXq951h0iSIvyidejsAa3a87mtsPHNr8v0+8ldGnXzJPm7B+nXE9u1aMMs+br5qUZI/TzPu/vYVn2+40MNaHS/ovzjdPzcEX2waa4+3b5I3WrdIUlqEN5CDcJb/HnM8W3648w+9W94n/756d0a3mK8fFwr6Zmvxig2qJa8XX2L9bkASppvZU/V6FDV7BgAAAC4CqaiAgAAgGkcnR3UqG91s2OUOj6ulRTqHW7XFuodrlPnT0iSMrMytHTrQvWtP1x1KzdVlUpRalu9uxpH3KSvdi7J97wfb3tXzSLb6qboTqriG6UG4S3Uq85gfbHj38oxcnL1v5R9Se/99IbubPyATpw7opycbMUF1VaIdxUFeVW2TWkFlCfNByXI6sCfygAAAKUZ79YAAABgqphWYfKP9DY7RqkSE1hDR88dsms7du6Q/D2CJEnZRrayc7JksVjs+lgtDjKUu0BxRWZWRq5jLJb//UlgGLn6f/bL+6oV2lBV/WKUY+Qo28i27cvOyVbOX7aB8qBq42BVrh1gdgwAAABcA4UNAAAAmMpisajpwHizY5Qq7eN6aV/KLn32ywc6fu6w1u//Vqv3fKHE2G6SJDcnd1UPqq3/2/y2dh/bqhNpR7Xm96+1dv9K1a/y5zRSSWtf1JLN823bdSs30arfPtOPB1bpRNpR7TiySf/Z9q7qVG4iq9XBLsPhs8n6KXm1etS5U5IU4l1FVln1371fauuhH3U09aAi/Rhtg/LDwcmqZvwuAgAAKBNYYwMAAACmC6vhr9ibK+u31Yeu3bkCiPKvrhE3PaGlWxbo0+2LFOAZon4N7lWzyDa2Pve0GK8lWxborbUvKD3znPzdg9SzziC1juli63Pq/Ik/R2RI6lqzvySLPt76js5cOCkvFx/VqdxEveoMtrt/wzD07o8z1bf+cLk4ukqSnB1dNKTZWC3aMEtZOVm6o9EIVXLnk+0oP+r1jJZXoLvZMQAAAFAAFDYAAABQKjQbmKA/tqbowpkMs6OUCnUrN1Xdyk3z3e/j5qehzcZd9RyPtHvObtvB6qBbaw/QrbUHXPU4i8Wi8be8eN2ZgLLKJ8xDdbpXMzsGgBtw6NAhjR8/Xl988YXOnz+vmJgYzZ8/X40aNcqz/5AhQ7Rw4cJc7TVq1NAvv/yS5zHfffed2rRpo9OnT8vX19duX2RkpMaMGaMxY8bc6EMBABQAU1EBAACgVHDxdFKLwQlmxwBQAbUcWlMOjvx5DJRVp0+fVsuWLeXk5KQvvvhCO3bs0EsvvaRKlSrle8yrr76qI0eO2G4HDx6Un5+fbrvtthJMDgAoLN65AQAAoNSIahqqqo2DzY4BoAKJaRWmsJr+ZscAcAOee+45hYeHa/78+WrSpImioqLUoUMHRUdH53uMj4+PQkJCbLcNGzbo9OnTGjp06A3nWbBggSwWS67b5MmTb/jcAIDLKGwAAACgVGk5pIac3ZkxFUDxc/F0UtMBLBgOlHXLli1To0aNdNtttykoKEj169fXvHnzruscSUlJat++vapWrXrDefr162c3GuT999+Xo6OjWrZsecPnBgBcVqYKG5MnT85V7Y6P//NN6MWLFzVy5Ej5+/vL09NTffr00bFjx0xMDAAAgOvlXslVTbjQCKAEtBpWU24+LmbHAHCDfv/9d82ePVuxsbH68ssvNWLECD344IN5rqGRl8OHD+uLL77Q3XffXaD+VapUkaenp90tOTnZtt/Nzc02EiQ9PV0jR47UM888o1tuuaVQjw8AkFuZ+yhczZo1tWLFCtu2o+OfD2Hs2LH67LPP9O9//1s+Pj4aNWqUevfurTVr1pgRFQAAAIUU3yZcv/9wRId/OWl2FADlVEyrMEU1DTU7BoAikJOTo0aNGumZZ56RJNWvX1/bt2/XnDlzNHjw4Gsev3DhQvn6+qpnz54Fur///ve/8vLysmtLTEzM1e/s2bPq1q2bunbtqkceeaRA5wYAFEyZK2w4OjoqJCQkV/vZs2eVlJSkRYsWqW3btpKk+fPnKyEhQevWrVOzZs1KOioAAABuQKu7a2rJY2uUlZFtdhQA5YxngJtaDKlhdgwARSQ0NFQ1atj/TCckJOijjz665rGGYejtt9/WnXfeKWdn5wLdX1RUlHx9fe3a/vrBW0nKzs5Wv3795O3trTfffLNA5wUAFFyZmopKkn777TeFhYWpWrVqGjBggG2o38aNG3Xp0iW1b9/e1jc+Pl4RERFau3atWXEBAABQSN7BHmrwj1izYwAoZywWqfWI2nJ2dzI7CoAi0rJlS+3evduu7ddffy3QehmrVq3Snj17NGzYsCLNNHbsWG3btk0ff/yxXF1di/TcAIAyVtho2rSpFixYoOXLl2v27Nnat2+fbrrpJp07d05Hjx6Vs7Nzrop5cHCwjh49etXzZmRkKDU11e4GAAAA89XqHKmQ+EpmxwBQjtTqEqXQBH+zYwAoQmPHjtW6dev0zDPPaM+ePVq0aJHefPNNjRw50tZnwoQJGjRoUK5jk5KS1LRpU9WqVavI8syfP1+zZs3SnDlzZLFYdPToUR09elRpaWlFdh8AUNGVqcJG586dddttt6lOnTrq2LGjPv/8c505c0YffvjhDZ13+vTp8vHxsd3Cw8OLKDEAAABuhNVqUZtR9eTqxSerAdw4vwgvNepX3ewYAIpY48aNtXTpUr3//vuqVauWnnrqKc2YMUMDBgyw9Tly5IjdAt/S5WnNP/rooyIfrbFq1SplZ2fr1ltvVWhoqO324osvFun9AEBFVubW2PgrX19fVa9eXXv27NEtt9yizMxMnTlzxm7UxrFjx/Jck+OvJkyYoHHjxtm2U1NTKW4AAACUEh5+rmo9oq6+fGGDZJidBkBZ5eBkVev768jBsUx9vg9AAXXr1k3dunXLd/+CBQtytfn4+Oj8+fMFvo/ExEQZRt5vRvbv3293X3ndHwCg6JTpd3RpaWnau3evQkND1bBhQzk5OWnlypW2/bt371ZycrKaN29+1fO4uLjI29vb7gYAAIDSI7xeoOp0izI7BoAyrOFtsfKP4G89AACA8qBMjdh4+OGH1b17d1WtWlWHDx/WpEmT5ODgoP79+8vHx0fDhg3TuHHj5OfnJ29vbz3wwANq3ry5mjVrZnZ0AAAA3KBGfavr6O7TOv7rGbOjAChjQmv4qXYXiqMAAADlRZkqbPzxxx/q37+/Tp48qcDAQLVq1Urr1q1TYGCgJOmVV16R1WpVnz59lJGRoY4dO2rWrFkmpwYAAEBRsDpY1faBelo6YY0y0i6ZHQdAGeHu66LEkXVlsVrMjgIAAIAiUqYKG4sXL77qfldXV73xxht64403SigRAAAASpKnv5ta31dHX720kfU2AFyT1dGidmPqy6OSq9lRAAAAUITK9BobAAAAqHgiGgQxpQyAAmk+uIaCq1cyOwYAAACKWJkasQEAAABIUuN+1XV09ymd2HPW7CgASqn4tuFKaBdhdgygXEtOTlZKSorZMXCdAgICFBHB70cAZRuFDQAAAJQ5Vker2j1YXx8/8YMupmaaHQdAKRNU3VfNh9QwOwZQriUnJysuIV4Xz18wOwquk6u7m3bv3EVxA0CZRmEDQLkze/ZszZ49W/v375ck1axZU08++aQ6d+4sSTp69KgeeeQRff311zp37pzi4uL0z3/+U3369Lnqed944w298MILOnr0qOrWravXXntNTZo0Ke6HAwDIh2eAmzo83FCfPb1e2Zk5ZscBUEq4V3JR+9H15eDIzMtAcUpJSdHF8xcU/lQnuUT5mR0HBZSx75QOTlyulJQUChsAyjQKGwDKnSpVqujZZ59VbGysDMPQwoUL1aNHD/3888+qWbOmBg0apDNnzmjZsmUKCAjQokWL1LdvX23YsEH169fP85wffPCBxo0bpzlz5qhp06aaMWOGOnbsqN27dysoKKiEHyEA4IqgGF8ljqijlTM3s5g4AFkdLWo/pr7cWSwcKDEuUX5yjw82OwYAoILhIywAyp3u3burS5cuio2NVfXq1TVt2jR5enpq3bp1kqQffvhBDzzwgJo0aaJq1arpiSeekK+vrzZu3JjvOV9++WUNHz5cQ4cOVY0aNTRnzhy5u7vr7bfftvWxWCyaO3euunXrJnd3dyUkJGjt2rXas2ePEhMT5eHhoRYtWmjv3r22Y7Zs2aI2bdrIy8tL3t7eatiwoTZs2FB8Tw4AlENRTUPVuF91s2MAKAVaDq2poFgWCwcAACjvKGwAKNeys7O1ePFipaenq3nz5pKkFi1a6IMPPtCpU6eUk5OjxYsX6+LFi0pMTMzzHJmZmdq4caPat29va7NarWrfvr3Wrl1r1/epp57SoEGDtHnzZsXHx+uOO+7QvffeqwkTJmjDhg0yDEOjRo2y9R8wYICqVKmin376SRs3btRjjz0mJyenon8iAKCcq3trtOLaVDE7BgATJbSPUFybcLNjAAAAoAQwFRWAcmnbtm1q3ry5Ll68KE9PTy1dulQ1alxeQPLDDz9Uv3795O/vL0dHR7m7u2vp0qWKiYnJ81wpKSnKzs5WcLD98Org4GDt2rXLrm3o0KHq27evJGn8+PFq3ry5Jk6cqI4dO0qSRo8eraFDh9r6Jycn65FHHlF8fLwkKTY2tmieAACogFreVVPnTlzQ4e0nzY4CoIRFNAhS88EJZscAAABACWHEBoByKS4uTps3b9b69es1YsQIDR48WDt27JAkTZw4UWfOnNGKFSu0YcMGjRs3Tn379tW2bdtu+H7r1Klj+/pKIaR27dp2bRcvXlRqaqokady4cbr77rvVvn17Pfvss3bTVAEAro/Vwar2Y+rLt7Kn2VEAlKCQ+Epq+2A9WR348xYAAKCi4J0fgHLJ2dlZMTExatiwoaZPn666devq1Vdf1d69e/X666/r7bffVrt27VS3bl1NmjRJjRo10htvvJHnuQICAuTg4KBjx47ZtR87dkwhISF2bX+dRspiseTblpOTI0maPHmyfvnlF3Xt2lXffPONatSooaVLl974EwAAFZSzu5M6PtpQrt7OZkcBUAL8qnqpw8MN5ejsYHYUAAAAlCAKGwAqhJycHGVkZOj8+fOSLq+R8VcODg62YsPfOTs7q2HDhlq5cqXd+VauXGlbt+NGVK9eXWPHjtVXX32l3r17a/78+Td8TgCoyLwC3dXh4YZycOatLlCeeQe7q9NjjeXszvpkAAAAFQ1/7QEodyZMmKDVq1dr//792rZtmyZMmKDvvvtOAwYMUHx8vGJiYnTvvffqxx9/1N69e/XSSy/p66+/Vs+ePW3naNeunV5//XXb9rhx4zRv3jwtXLhQO3fu1IgRI5Senm63Xsb1unDhgkaNGqXvvvtOBw4c0Jo1a/TTTz8pIYH5oQHgRgXF+Kr9mAayOlrMjgKgGLj7uqjzhMZy93ExOwoAAABMwOLhAMqd48ePa9CgQTpy5Ih8fHxUp04dffnll7rlllskSZ9//rkee+wxde/eXWlpaYqJidHChQvVpUsX2zn27t2rlJQU23a/fv104sQJPfnkkzp69Kjq1aun5cuX51pQ/Ho4ODjo5MmTGjRokI4dO6aAgAD17t1bU6ZMKfyDBwDYhNcLVLvR9bVyxs/KyTbMjgOgiDi7O6rTY43lFeRudhQAAACYhMIGgHInKSnpqvtjY2P10UcfXbXP2rVrdeTIEW3atMnW1qJFi1zrX/x1/8aNGxUaGmrbjoyMlGHYX0hLTEy0a3v//fevmgMAcGOqNgxW2wfraeXMzTIobgBlnoOzVR0eaSS/CC+zowAAAMBEFDYAIA9z584t1MiJSZMmafLkyUUfCABQaJGNQ9RmZF19+/oWGTkUN4CyyuJgUfvR9RUSV8nsKAAAADAZhQ0AyMO9996rW2+91a7twoULatWqlSTp+++/l5ubW67j/jpiAwBQelRrFiojx9B3s7ZS3ADKIIuDRYn311V4/SCzowAAAKAUoLABAHkIDQ3NVaRIT0+3fV2vXj15eHiUdCwAwA2IbhGmnGxDq+dslUFtAygzHJysavtgPVVtWPi1zQAAAFC+UNgAAABAhRF7U2UZ2YZWz9smUdwASj1HFwfdMq6BKtcOMDsKAAAAShEKGwAAAKhQqidWUU6Ooe+TtlPcAEoxZ3dHdXikEWtqAAAAIBcKGwBKleTkZKWkpJgdI08XLlywfb158+Y819goLQICAhQREWF2DAAoteLbhsvqYNF/39ouI5vqBlDauHo5qdNjjRUQ5WN2FAAAAJRCFDYAlBrJyclKiIvT+YsXzY5yTVcWES+t3F1dtXP3boobAHAV1VtXkZuvi1bO+FlZGdlmxwHwP+6+Lur8eGNVquJldhQAAACUUhQ2AJQaKSkpOn/xol6vV12xXu5mx8nlYna2evywTZL0nxa15ergYHKivP127rxGbf5VKSkpFDYA4BrC6waq28Sm+vKFDbpwNtPsOECF5xngpi7/bCzvYA+zowAAAKAUo7ABoNSJ9XJXHR9Ps2Pkcj7rz0/z1vL2lLtj6SxsAACuT0A1H3Wf3FzLn/tJqUfPmx0HqLB8Qj3U+fHG8vQvvdN9AgAAoHSwmh0AAAAAMJt3sLtundxcgTHM5w+YIai6r7o92ZSiBgAAAAqEwgYAAAAgydXbWV3/2VTh9QPNjgJUKLE3V1bXJ5rKzcfF7ChAqTZ58mRZLBa7W3x8vNmxAAAwBVNRAQAAAP/j6OKgWx5qqDVJv2j3twfNjgOUaxaL1PiOeNXpGmV2FKDMqFmzplasWGHbdnTksg4AoGLif0AAyMOxi5k6lmG/iOzFv6yxsf1smlzzWGMj2MVZwa7OxZ4PAFB8rFaLbhpeSx7+Ltr00R7JMDsRUP44uTmqzai6iqgfZHYUoExxdHRUSEiI2TEAADAdhQ0AyMO7B47opd/y/6Ruj7Xb8mx/KDZcD8dVLa5YAIAS1KB3rPyremvV7K3KPJ9ldhyg3PAKclOHhxuqUhUvs6MAZc5vv/2msLAwubq6qnnz5po+fboiIiLMjgUAQImjsAEAebizaqg6hPhf93HBLozWAIDypGrDYPWc1kIrZvysUwfOmR0HKPNCa/ip3ej6cvXiPRNwvZo2baoFCxYoLi5OR44c0ZQpU3TTTTdp+/bt8vLKXSjMyMhQRkaGbTs1NbUk4wIAUKwobABAHoJdmVIKAHCZd7CHbp3SXGuSftFv/z1kdhygzIpvG64WQ2rI6mg1OwpQJnXu3Nn2dZ06ddS0aVNVrVpVH374oYYNG5ar//Tp0zVlypSSjAgAQInhHSUAAABwDY7ODmo9oo5aDqspByfeQgPXw8HJqhZDa6jV3bUoagBFyNfXV9WrV9eePXvy3D9hwgSdPXvWdjt4MP+pdgEAKGsYsQEAAAAUUEK7CAVE+WjljJ+VlnLB7DhAqedb2VNtH6gnvwjW0wCKWlpamvbu3as777wzz/0uLi5ycXEp4VQAAJQMPi4DAAAAXIfAaj7qOa2FqtQJMDsKUKrFtwtXz2ktKGoAReThhx/WqlWrtH//fv3www/q1auXHBwc1L9/f7OjAQBQ4hixAQAAAFwnVy9ndXy0kTYt2aPNS/fIMMxOBJQeLp5Ouml4LUU2DjE7ClCu/PHHH+rfv79OnjypwMBAtWrVSuvWrVNgYKDZ0QAAKHEUNgAAAIBCsFgtaviPWFWuHaBVs7fo3HGmpgJCa/gp8f668vBzNTsKUO4sXrzY7AgAAJQaTEUFAAAA3ICQuErq/WwrxbcNNzsKYBqLg0WN+lZXl8ebUNQAAABAsWPEBgAAAHCDnFwd1eruWqraMEir523XhTMZZkcCSoxXoJvajKqroNhKZkcBAABABcGIDQAAAKCIhNcPUp/nWymmVZjZUYBiZ7FINTpWVa9nW1HUAAAAQIlixAYAAABQhFw9nZV4f11FNw/V90m/KP3URbMjAUXOP9Jbre6upcBqPmZHAQAAQAVEYQMAAAAoBpdHb1TS+vd2a/e3B82OAxQJJ1cHNbwtVjU6RspqtZgdBwAAABUUhQ0AAACgmDi7O+mm4bUU0ypUa9/ZqVMHzpkdCSi0qg2D1GJIDXn4u5kdBQAAABUchQ0AAACgmIUm+KvntJba/e1BbfzwV108d8nsSECBefi7qsXgGqraKNjsKAAAAIAkChsAAABAibBaLUpoF6FqzUL185I92vHVAeVkG2bHAvJlsVpUs2NVNbwtVk6u/OkIAACA0oN3pwAAAEAJcvFwUrM7ExTfNlzr/rVTf2xJMTsSkEvl2gFqMiBO/hHeZkcBAAAAcrGaHQAAAABl04IFC+Tr62t2jGJXXI/Tt7KnOo1vrA6PNJRPqEeRnx8oDP+qXur0WCN1ntCYogYAAABKrTJV2Jg+fboaN24sLy8vBQUFqWfPntq9e7ddn8TERFksFrvbfffdZ1JiAACA0mPt2rVycHBQ165dr/vYyMhIzZgxw66tX79++vXXX4soXf4SExM1ZsyYXO3lpbASUT9IfZ5rpSYD4uXszoBqmMPD31Wt76ujntNaqkqdQLPjAAAAAFdVpv5yWrVqlUaOHKnGjRsrKytLjz/+uDp06KAdO3bIw+PPT7kNHz5cU6dOtW27u7ubERcAAKBUSUpK0gMPPKCkpCQdPnxYYWFhN3Q+Nzc3ubm5FVG6is3qaFWdrlGKa11F25fv1y/L9yvzfJbZsVABuPk4q+6t0UpoHy4HJwez4wAAAAAFUqZGbCxfvlxDhgxRzZo1VbduXS1YsEDJycnauHGjXT93d3eFhITYbt7eDKEGAAAVW1pamj744AONGDFCXbt21YIFC3L1+eSTT9S4cWO5uroqICBAvXr1knR5xMSBAwc0duxY24hYKe8RE7Nnz1Z0dLScnZ0VFxend999126/xWLRW2+9pV69esnd3V2xsbFatmxZkT3O//znP2rQoIFcXV1VrVo1TZkyRVlZfxYIXn75ZdWuXVseHh4KDw/X/fffr7S0NLtzLFiwQBEREXJ3d1evXr108uTJIst3LS6eTmr4j1jdPjNRDfvGysXTqcTuGxWLi4eTGt9eXX1faa1anSMpagAAAKBMKVOFjb87e/asJMnPz8+u/b333lNAQIBq1aqlCRMm6Pz581c9T0ZGhlJTU+1uAAAA5cmHH36o+Ph4xcXFaeDAgXr77bdlGIZt/2effaZevXqpS5cu+vnnn7Vy5Uo1adJEkrRkyRJVqVJFU6dO1ZEjR3TkyJE872Pp0qUaPXq0HnroIW3fvl333nuvhg4dqm+//dau35QpU9S3b19t3bpVXbp00YABA3Tq1Kkbfoz//e9/NWjQII0ePVo7duzQ3LlztWDBAk2bNs3Wx2q1aubMmfrll1+0cOFCffPNN3r00Udt+9evX69hw4Zp1KhR2rx5s9q0aaOnn376hrNdL2d3J9XvGaPbZyaqcf84uXo7l3gGlE8unk6q3ztG/V5trbq3RsvJtUwN4gcAAAAklbGpqP4qJydHY8aMUcuWLVWrVi1b+x133KGqVasqLCxMW7du1fjx47V7924tWbIk33NNnz5dU6ZMKYnYAAAApkhKStLAgQMlSZ06ddLZs2e1atUqJSYmSpKmTZum22+/3e49Ud26dSVd/hCJg4ODvLy8FBISku99vPjiixoyZIjuv/9+SdK4ceO0bt06vfjii2rTpo2t35AhQ9S/f39J0jPPPKOZM2fqxx9/VKdOnfI996xZs/TWW2/ZtWVlZcnV1dW2PWXKFD322GMaPHiwJKlatWp66qmn9Oijj2rSpEmSZLdWR2RkpJ5++mndd999mjVrliTp1VdfVadOnWzFjurVq+uHH37Q8uXL881WnJxcHVW3ezXV7FBVO1cka+tn+3ThTIYpWVC2eYe4q1bnSFW/uYocXRidAQAAgLKtzBY2Ro4cqe3bt+v777+3a7/nnntsX9euXVuhoaFq166d9u7dq+jo6DzPNWHCBI0bN862nZqaqvDw8OIJDgAAUMJ2796tH3/8UUuXLpUkOTo6ql+/fkpKSrIVNjZv3qzhw4ff0P3s3LnT7r2YJLVs2VKvvvqqXVudOnVsX3t4eMjb21vHjx+/6rkHDBigf/7zn3ZtS5Ys0TPPPGPb3rJli9asWWM3QiM7O1sXL17U+fPn5e7urhUrVmj69OnatWuXUlNTlZWVZbd/586dtim4rmjevLlphY0rHF0cVLtrlBJuidDubw9q6yf7lH7qoqmZUDaExFdS7a5RiqgfJIvVYnYcAAAAoEiUycLGqFGj9Omnn2r16tWqUqXKVfs2bdpUkrRnz558CxsuLi5ycXEp8pwAAAClQVJSkrKysuwWCzcMQy4uLnr99dfl4+NToouAOznZrxthsViUk5Nz1WN8fHwUExNj1xYUFGS3nZaWpilTpqh37965jnd1ddX+/fvVrVs3jRgxQtOmTZOfn5++//57DRs2TJmZmXJ3dy/kIyo5js4OqtkxUgntInRg4zHtXHFQh38puTVAUDZYHCyKahKi2l2jFFjNx+w4AAAAQJErU4UNwzD0wAMPaOnSpfruu+8UFRV1zWM2b94sSQoNDS3mdAAAAKVPVlaW3nnnHb300kvq0KGD3b6ePXvq/fff13333ac6depo5cqVGjp0aJ7ncXZ2VnZ29lXvKyEhQWvWrLFNBSVJa9asUY0aNW78gRRAgwYNtHv37lwFkCs2btyonJwcvfTSS7JaLy819+GHH9r1SUhI0Pr16+3a1q1bVzyBb4DV0aqopqGKahqqM4fTtGvlQf22+pAy0i+ZHQ0mcnJzVFybKqrVKVKeASVXrAQAAABKWpkqbIwcOVKLFi3Sf/7zH3l5eeno0aOSZPuU4d69e7Vo0SJ16dJF/v7+2rp1q8aOHaubb77ZbsoDAACAiuLTTz/V6dOnNWzYMPn42H9yu0+fPkpKStJ9992nSZMmqV27doqOjtbtt9+urKwsff755xo/fryky+tRrF69WrfffrtcXFwUEBCQ674eeeQR9e3bV/Xr11f79u31ySefaMmSJVqxYkWJPNYnn3xS3bp1U0REhP7xj3/IarVqy5Yt2r59u55++mnFxMTo0qVLeu2119S9e3etWbNGc+bMsTvHgw8+qJYtW+rFF19Ujx499OWXX5o+DdW1+IZ5qtmdCWrUr7p+X3tEO1ck68Tes2bHQgkKjPFR7E2VFdMyTM7uTtc+AAAAACjjrGYHuB6zZ8/W2bNnlZiYqNDQUNvtgw8+kHT5k4QrVqxQhw4dFB8fr4ceekh9+vTRJ598YnJyAAAAcyQlJal9+/a5ihrS5cLGhg0btHXrViUmJurf//63li1bpnr16qlt27b68ccfbX2nTp2q/fv3Kzo6WoGBgXneV8+ePfXqq6/qxRdfVM2aNTV37lzNnz/fto5HcevYsaM+/fRTffXVV2rcuLGaNWumV155RVWrVpV0eTH0l19+Wc8995xq1aql9957T9OnT7c7R7NmzTRv3jy9+uqrqlu3rr766is98cQTJZL/Rjk6O6h66yrq8VQL9ZzWQnFtWCS6PPPwd1XdW6vpHy/cpB5TW6jGLVUpagAAAKDCKFMjNgzDuOr+8PBwrVq1qoTSAAAAlH5X+4BHkyZN7N5f9e7dO8/1KaTLF/y3bNli1zZkyBANGTLErm3EiBEaMWJEvveZ1/u5M2fO5Ntfkr777rs82/O6/44dO6pjx475nmvs2LEaO3asXdudd95pt33XXXfprrvusmt76KGHrpqxtAmI8tFNw2ur6YB4/b7+qPatO6LDO07JyL76+2mUbo4uDopsHKzYmysrrIY/i4EDAACgwipThQ0AAAAABefs7qT4NuGKbxOui+cytX/DMYocZY1FCqvhr5ibwhTVJEROrvwJBwAAAPCuGAAAAKgAXL2c8yhyHNXhHScpcpQyDk5WhSb4Kbx+oKo2DGYhcAAAAOBvKGwAAAAAFUx+RY4jO08qJ4sihxncK7kovF6QIuoHKqyWPyMzAAAAgKvg3TIAAABQgf21yJGVka2ju0/p8C+ndPiXkzq576yuscwdCslikQKifRRRL0jhDQIVEOljdiQAAACgzKCwAQAAAEDS5cWpq9QJVJU6gZKkjPRLOrLjlA7vOKnD20/qzKE0kxOWYRbJN8xTQbG+ComvpPC6gXLzcTE7FQAAAFAmUdgAAAAAkCcXDydFNg5WZONgSdL5Mxk6/MtJHf7lpI7/dkZnj6TLyGFIR16c3R0VGO2roFhfBcf6KjDGVy4eTmbHAgAAAMoFChsAAAAACsTd10UxLcMU0zJMkpSVma1Tyed06kCqTh44p5P7U3Xq4DllZWSbnLRkWSySd6iHgmN9FRRbSUGxvqpU2VMWq8XsaAAAAEC5RGEDAAAAQKE4OjsoKMZXQTG+tjYjx9DZo+k6uf9ysePUgVSd/iNN509fLPPrdTi7O8onzEO+oZ7yCfWQT5jH5X9D3OXg5GB2PAAAAKDCoLABAAAAoMhYrBb5hnnKN8xT0S3+bM/JzlH6qYtKS7mgtJQr//7l65MXlJ2ZY2Lwy1NvuXo5y83HWa7ezvIKdP9fIeNyAYM1MQAAAIDSgcIGAAAAgGJndbDKK9BdXoHu+fa5kJqh9JMXdTHtkjLTLynzfJYy0y8p43yWLl3IUlZGlrIycpSVma2sjMs3I8eQxcEiq4NFFqtFVgfr5a//12a1Wm1fOzha5eLlLDdvJ7l6u8jN+3IB48q/VgdrCT4jAAAAAAqLwgYAAACAUsHN20Vu3oyKAAAAAHB1fCQJAAAAAAAAAACUGRQ2AAAAAAAAAABAmUFhAwAAAAAAAAAAlBkUNgAAAAAAAAAAQJlBYQMAAAAAAAAAAJQZFDYAAAAAAAAAAECZQWEDAAAAAAAAAACUGRQ2AAAAAAAAAABAmUFhAwAAAAAAAAAAlBkUNgAAAAAAAAAAQJlBYQMAAAAAAAAAAJQZFDaAYvLss8/KYrFozJgx+fZJTEyUxWLJdevatWvJBQUAAAAAAACAMsTR7ABAefTTTz9p7ty5qlOnzlX7LVmyRJmZmbbtkydPqm7durrtttuKOyIAAAAAAAAAlEmM2ACKWFpamgYMGKB58+apUqVKV+3r5+enkJAQ2+3rr7+Wu7u7XWEjMjJSTz/9tAYNGiRPT09VrVpVy5Yt04kTJ9SjRw95enqqTp062rBhg+2YAwcOqHv37qpUqZI8PDxUs2ZNff7558X2mAEAAAAAAACgpFDYAIrYyJEj1bVrV7Vv3/66j01KStLtt98uDw8Pu/ZXXnlFLVu21M8//6yuXbvqzjvv1KBBgzRw4EBt2rRJ0dHRGjRokAzDsGXIyMjQ6tWrtW3bNj333HPy9PQskscHAAAAAAAAAGZiKiqgCC1evFibNm3STz/9dN3H/vjjj9q+fbuSkpJy7evSpYvuvfdeSdKTTz6p2bNnq3HjxraRHePHj1fz5s117NgxhYSEKDk5WX369FHt2rUlSdWqVbuBRwUAAAAAAAAApQcjNoAicvDgQY0ePVrvvfeeXF1dr/v4pKQk1a5dW02aNMm1769rdQQHB0uSrWjx17bjx49Lkh588EE9/fTTatmypSZNmqStW7dedx4AAAAAAAAAKI0obABFZOPGjTp+/LgaNGggR0dHOTo6atWqVZo5c6YcHR2VnZ2d77Hp6elavHixhg0blud+Jycn29cWiyXftpycHEnS3Xffrd9//1133nmntm3bpkaNGum111674ccIAAAAAAAAAGajsAEUkXbt2mnbtm3avHmz7daoUSMNGDBAmzdvloODQ77H/vvf/1ZGRoYGDhxYZHnCw8N13333acmSJXrooYc0b968Ijs3AAAAAAAAAJiFNTaAIuLl5aVatWrZtXl4eMjf39/WPmjQIFWuXFnTp0+365eUlKSePXvK39+/SLKMGTNGnTt3VvXq1XX69Gl9++23SkhIKJJzAwAAAAAAAICZKGwAJSg5OVlWq/1Aqd27d+v777/XV199VWT3k52drZEjR+qPP/6Qt7e3OnXqpFdeeaXIzg8AAAAAAAAAZqGwARSj77777qrbkhQXFyfDMPI9x/79+3O1/b1/ZGSkXRvraQAAAAAAAAAor1hjAwAAAAAAAAAAlBkUNgAAAAAAAAAAQJlBYQMAAAAAAAAAAJQZrLEBmOzIkSM6cuTIdR8XGhqq0NDQYkgEAAAAAAAAAKUXhQ3AZHPnztWUKVOu+7hJkyZp8uTJRR8IAAAAAAAAAEoxChuosJKTk5WSkmJ2DDVv3lz/+te/7NoyMjI0bNgwSVJSUpJcXFxyHRcQEKBNmzaVSMarCQgIUEREhNkxAAAAAAAAAFQQFDZQISUnJysuPkEXL5w3O8o1XSlwlFaubu7avWsnxQ0AAAAAAAAAJYLCBiqklJQUXbxwXlFDX5RraIypWU6sfl8p339w3ccFtOqnwJv7F0Oigrt4ZI/2zX9YKSkpFDYAAAAAAAAAlAgKG6jQXENj5BFR09QMTt0fLFSBwsknUM4+QcWQCAAAAAAAAABKLwobgMmcfYIoUAAAAAAAAABAAVnNDgAAAAAAAAAAAFBQFDYAAAAAAAAAAECZUW4LG2+88YYiIyPl6uqqpk2b6scffzQ7EgAAAAAAwA3hegcAAOW0sPHBBx9o3LhxmjRpkjZt2qS6deuqY8eOOn78uNnRAAAAAAAACoXrHQAAXFYuCxsvv/yyhg8frqFDh6pGjRqaM2eO3N3d9fbbb5sdDQAAAAAAoFC43gEAwGWOZgcoapmZmdq4caMmTJhga7NarWrfvr3Wrl2b5zEZGRnKyMiwbZ89e1aSlJqaesN50tLSJEkXdh5XzvlLN3y+iirjwGlJl5/Povy+nD+wXdkZ52/4fBVVxtHfJRX992XrmXNKz8q+4fNVVHvTLr+mi/r7cuDUHmVkXbjh81VUR1MPSSq678uVcxiGccPnAgAAQOl3vdc7ivNah8T1jrKqqK+vXAt/55ddRX1t4Vq49lB2FeX1juu51mExytkVkcOHD6ty5cr64Ycf1Lx5c1v7o48+qlWrVmn9+vW5jpk8ebKmTJlSkjEBACgSBw8eVJUqVcyOAQAAgGJ2vdc7uNYBACirCnKto9yN2CiMCRMmaNy4cbbtnJwcnTp1Sv7+/rJYLCYmKxmpqakKDw/XwYMH5e3tbXYc/A/fl9KJ70vpVBG/L4Zh6Ny5cwoLCzM7CgAAAEqhin6t40ZUxL8vUDi8VlAQvE4K7nqudZS7wkZAQIAcHBx07Ngxu/Zjx44pJCQkz2NcXFzk4uJi1+br61tcEUstb29vfrhKIb4vpRPfl9Kpon1ffHx8zI4AAACAEnK91zu41nHjKtrfFyg8XisoCF4nBVPQax3lbvFwZ2dnNWzYUCtXrrS15eTkaOXKlXZDNQEAAAAAAMoKrncAAPCncjdiQ5LGjRunwYMHq1GjRmrSpIlmzJih9PR0DR061OxoAAAAAAAAhcL1DgAALiuXhY1+/frpxIkTevLJJ3X06FHVq1dPy5cvV3BwsNnRSiUXFxdNmjQp1xBVmIvvS+nE96V04vsCAACAioDrHSWDvy9QULxWUBC8ToqHxTAMw+wQAAAAAAAAAAAABVHu1tgAAAAAAAAAAADlF4UNAAAAAAAAAABQZlDYAAAAAAAAAAAAZQaFDQD4m8jISM2YMSPf/YmJiRozZkyJ5SnPFixYIF9fX7NjFLuK8jgBAAAAoLzhGkHFVVH+li+rj5PCRjk1ZMgQWSyWXLdOnTrp1KlTeuCBBxQXFyc3NzdFRETowQcf1NmzZ23H79+/P8/jLRaL1q1bZ+IjKzl/fQ6dnJwUHBysW265RW+//bZycnKu61xF+QsiMTHRlsvV1VU1atTQrFmziuTcZcHfX9v+/v7q1KmTtm7dana0CmHt2rVycHBQ165dr/vYvN4M9uvXT7/++msRpctffm80y+p/3gAAAACuD9dJyieuEeCvuGZRsVDYKMc6deqkI0eO2N3ef/99HT58WIcPH9aLL76o7du3a8GCBVq+fLmGDRuW6xwrVqzIdY6GDRua8GjMceU53L9/v7744gu1adNGo0ePVrdu3ZSVlWVaruHDh+vIkSPasWOH+vbtq5EjR+r999/Ps29mZmYJpyt+f31tr1y5Uo6OjurWrZvZsSqEpKQkPfDAA1q9erUOHz58w+dzc3NTUFBQESQDAAAAgKvjOkn5xDUCXME1i4qFwkY55uLiopCQELtbpUqVVKtWLX300Ufq3r27oqOj1bZtW02bNk2ffPJJrov1/v7+uc7h5ORk0iMqeVeew8qVK6tBgwZ6/PHH9Z///EdffPGFFixYYOv38ssvq3bt2vLw8FB4eLjuv/9+paWlSZK+++47DR06VGfPnrV9gmDy5MmSpHfffVeNGjWSl5eXQkJCdMcdd+j48ePXzOXu7q6QkBBVq1ZNkydPVmxsrJYtWybpcpV31KhRGjNmjAICAtSxY0dJ0vbt29W5c2d5enoqODhYd955p1JSUmznvHLcqFGj5OPjo4CAAE2cOFGGYRTRs1l0/vrarlevnh577DEdPHhQJ06ckCSNHz9e1atXl7u7u6pVq6aJEyfq0qVLduf45JNP1LhxY7m6uiogIEC9evXK9/7eeust+fr6auXKlba2rKysqz5Xp0+f1qBBg1SpUiW5u7urc+fO+u2332z7r1Tdv/zySyUkJMjT09P2Zuzv952QkCBXV1fFx8ebOjonLS1NH3zwgUaMGKGuXbva/Qxckd/zmpiYqAMHDmjs2LG2nwMp708fzJ49W9HR0XJ2dlZcXJzeffddu/0Wi0VvvfWWevXqJXd3d7vXf1H4z3/+owYNGsjV1VXVqlXTlClT7H43Xu3n/YoFCxYoIiJC7u7u6tWrl06ePFlk+QAAAAAUDtdJyieuEUDimsUVFemaBYUNSJLOnj0rb29vOTo6mh2l1Gvbtq3q1q2rJUuW2NqsVqtmzpypX375RQsXLtQ333yjRx99VJLUokULzZgxQ97e3rZPEDz88MOSpEuXLumpp57Sli1b9PHHH2v//v0aMmTIdWdyc3OzG5mxcOFCOTs7a82aNZozZ47OnDmjtm3bqn79+tqwYYOWL1+uY8eOqW/fvnbnWbhwoRwdHfXjjz/q1Vdf1csvv6y33nqrEM9SyUlLS9O//vUvxcTEyN/fX5Lk5eWlBQsWaMeOHXr11Vc1b948vfLKK7ZjPvvsM/Xq1UtdunTRzz//rJUrV6pJkyZ5nv/555/XY489pq+++krt2rWztV/ruRoyZIg2bNigZcuWae3atTIMQ126dLF783T+/Hm9+OKLevfdd7V69WolJyfbXhuS9N577+nJJ5/UtGnTtHPnTj3zzDOaOHGiFi5cWGTP3/X48MMPFR8fr7i4OA0cOFBvv/223Ru1qz2vS5YsUZUqVTR16lTbz0Feli5dqtGjR+uhhx7S9u3bde+992ro0KH69ttv7fpNmTJFffv21datW9WlSxcNGDBAp06duuHH+N///leDBg3S6NGjtWPHDs2dO1cLFizQtGnTbH2u9vMuSevXr9ewYcM0atQobd68WW3atNHTTz99w9kAAAAAlByuk5RNXCOouLhmcVmFumZhoFwaPHiw4eDgYHh4eNjdpk2blqvviRMnjIiICOPxxx+3te3bt8+QZLi5ueU6R0UxePBgo0ePHnnu69evn5GQkJDvsf/+978Nf39/2/b8+fMNHx+fa97nTz/9ZEgyzp07l2+f1q1bG6NHjzYMwzCysrKMd99915BkvP7667b99evXtzvmqaeeMjp06GDXdvDgQUOSsXv3bttxCQkJRk5Ojq3P+PHjr/o4zfD317YkIzQ01Ni4cWO+x7zwwgtGw4YNbdvNmzc3BgwYkG//qlWrGq+88orx6KOPGqGhocb27dvt9l/rufr1118NScaaNWts+1NSUgw3Nzfjww8/NAzj8mtCkrFnzx5bnzfeeMMIDg62bUdHRxuLFi2yu++nnnrKaN68eb7Zi1OLFi2MGTNmGIZhGJcuXTICAgKMb7/91ra/oM/rX/39Z6NFixbG8OHD7frcdtttRpcuXWzbkownnnjCtp2WlmZIMr744ot877t169aGk5NTrt9nLi4udvffrl0745lnnrE79t133zVCQ0PzPffff9779+9vl9cwLv/OKMjvAAAAAADFg+sk5RPXCMy7RlDacM0ib+X5mgVl53KsTZs2mj17tl2bn5+f3XZqaqq6du2qGjVq2KZH+qsPPvhACQkJxRmzTDIMwzYsTbo8x+b06dO1a9cupaamKisrSxcvXtT58+fl7u6e73k2btyoyZMna8uWLTp9+rRtUfLk5GTVqFEj3+NmzZqlt956S5mZmXJwcNDYsWM1YsQI2/6/z++5ZcsWffvtt/L09Mx1rr1796p69eqSpGbNmtk9rubNm+ull15Sdna2HBwcrvGslJy/vrZPnz6tWbNmqXPnzvrxxx9VtWpVffDBB5o5c6b27t2rtLQ0ZWVlydvb23b85s2bNXz48Kvex0svvaT09HRt2LBB1apVy7X/as/Vzp075ejoqKZNm9r2+/v7Ky4uTjt37rS1ubu7Kzo62rYdGhpqm4osPT1de/fu1bBhw+yyZmVlycfHp6BPVZHZvXu3fvzxRy1dulSS5OjoqH79+ikpKUmJiYmSCva8XsvOnTt1zz332LW1bNlSr776ql1bnTp1bF97eHjI29v7mtO4DRgwQP/85z/t2pYsWaJnnnnGtr1lyxatWbPG7tMO2dnZdj/P1/p537lzZ65hy82bN9fy5csL9iQAAAAAKBZcJymfuEZQ8tcIShuuWVTMaxYUNsoxDw8PxcTE5Lv/3Llz6tSpk7y8vLR06dI854QMDw+/6jkqqp07dyoqKkqStH//fnXr1k0jRozQtGnT5Ofnp++//17Dhg1TZmZmvoWN9PR0dezYUR07dtR7772nwMBAJScnq2PHjtdc8PvKLzs3NzeFhobKarWfVc7Dw8NuOy0tTd27d9dzzz2X61yhoaHX89BLhb+/tt966y35+Pho3rx56tq1qwYMGKApU6aoY8eO8vHx0eLFi/XSSy/Z+ru5uV3zPm666SZ99tln+vDDD/XYY48Vy+P4+8+cxWKxDZO8Mv/hvHnz7N78SDKlyJSUlKSsrCyFhYXZ2gzDkIuLi15//XX5+PgU6HktKnk9d1cKg/nx8fHJ9fvs74uApaWlacqUKerdu3eu411dXQv98w4AAADAfFwnKZ+4RlB6PohqFq5ZVMxrFhQ2KqjU1FR17NhRLi4uWrZsmVxdXc2OVGZ888032rZtm8aOHSvp8qiLnJwcvfTSS7YCw4cffmh3jLOzs7Kzs+3adu3apZMnT+rZZ59VeHi4JGnDhg0FypDXL7uradCggT766CNFRkZedX7Q9evX222vW7dOsbGxpf4/SYvFIqvVqgsXLuiHH35Q1apV7arcBw4csOtfp04drVy5UkOHDs33nE2aNNGoUaPUqVMnOTo62s1rKV39uUpISFBWVpbWr1+vFi1aSJJOnjyp3bt3X3Ukzl8FBwcrLCxMv//+uwYMGFCgY4pLVlaW3nnnHb300kvq0KGD3b6ePXvq/fff13333XfN5zWvn4O/S0hI0Jo1azR48GBb25o1awr8vN2oBg0aaPfu3fn+fBXk5z0hISHP1wcAAACA0ovrJOUH1wgqFq5Z/KmiXbOgsFGOZWRk6OjRo3Ztjo6OcnZ2VocOHXT+/Hn961//UmpqqlJTUyVJgYGBdhexT548mescvr6+FeY/+CvPYXZ2to4dO6bly5dr+vTp6tatmwYNGiRJiomJ0aVLl/Taa6+pe/futgW7/yoyMlJpaWlauXKl6tatK3d3d0VERMjZ2Vmvvfaa7rvvPm3fvl1PPfVUsTyOkSNHat68eerfv78effRR+fn5ac+ePVq8eLHeeust2/c8OTlZ48aN07333qtNmzbptddes/sUQ2nx19f26dOn9frrr9tGpaSmpio5OVmLFy9W48aN9dlnn9mGIl4xadIktWvXTtHR0br99tuVlZWlzz//XOPHj7fr16JFC33++efq3LmzHB0dNWbMGNu+qz1XsbGx6tGjh4YPH665c+fKy8tLjz32mCpXrqwePXoU+HFOmTJFDz74oHx8fNSpUydlZGRow4YNOn36tMaNG1fIZ+/6ffrppzp9+rSGDRuWa4hrnz59lJSUpPvuu++az2tkZKRWr16t22+/XS4uLgoICMh1X4888oj69u2r+vXrq3379vrkk0+0ZMkSrVixokQe65NPPqlu3bopIiJC//jHP2S1WrVlyxZt375dTz/9dIF+3h988EG1bNlSL774onr06KEvv/yyTA7pBAAAAMobrpOUT1wjKNlrBKUN1ywq8DULU1f4QLEZPHiwISnXLS4uzvj222/z3CfJ2Ldvn2EYfy6Kldft/fffN/fBlZC/PoeOjo5GYGCg0b59e+Ptt982srOz7fq+/PLLRmhoqOHm5mZ07NjReOeddwxJxunTp2197rvvPsPf39+QZEyaNMkwDMNYtGiRERkZabi4uBjNmzc3li1bZkgyfv7553xz/XXx8OvZ/+uvvxq9evUyfH19DTc3NyM+Pt4YM2aMbXGr1q1bG/fff79x3333Gd7e3kalSpWMxx9/3G7xq9Lg769tLy8vo3Hjxsb//d//2fo88sgjhr+/v+Hp6Wn069fPeOWVV3ItgvTRRx8Z9erVM5ydnY2AgACjd+/etn1/XzBq1apVhoeHhzFz5kzDMAr2XJ06dcq48847DR8fH9vr4tdff7Xtz2tB+aVLlxp//7X83nvv2XJWqlTJuPnmm40lS5YU9ukrlG7duuVaWOqK9evXG5KMLVu2GIZx9ed17dq1Rp06dQwXFxfb48zreZg1a5ZRrVo1w8nJyahevbrxzjvv2O2XZCxdutSuzcfHx5g/f36+jyG/n4u87n/58uVGixYtDDc3N8Pb29to0qSJ8eabb9r2F+TnPSkpyahSpYrh5uZmdO/e3XjxxRfL5EJcAAAAQHnBdZLyiWsEJX+NoLThmkXFvWZhMYz/TdYGoEJLTExUvXr1NGPGDLOjAAAAAAAAAEC+rNfuAgAAAAAAAAAAUDpQ2AAAAAAAAAAAAGUGU1EBAAAAAAAAAIAygxEbAAAAAAAAAACgzKCwAQAAAAAAAAAAygwKGwAAAAAAAAAAoMygsAEAAAAAAAAAAMoMChsAAAAAAAAAAKDMoLABAAAAAAAAAADKDAobAAAAAAAAAACgzKCwAQAAAAAAAAAAygwKGwAAAAAAAAAAoMz4f0cSWtv1RSqEAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1600x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, 3, figsize=(16, 5))\n",
    "\n",
    "# Plot 1: Bar chart of average times\n",
    "ax1 = axes[0]\n",
    "components = [\"E2E\", \"Data Prep\", \"Backbone\", \"Action Head\"]\n",
    "times = [np.mean(timing_results[k])*1000 for k in timing_results.keys()]\n",
    "stds = [np.std(timing_results[k])*1000 for k in timing_results.keys()]\n",
    "colors = ['#2ecc71', '#3498db', '#e74c3c', '#9b59b6']\n",
    "\n",
    "bars = ax1.bar(components, times, yerr=stds, capsize=5, color=colors, edgecolor='black')\n",
    "ax1.set_ylabel('Time (ms)', fontsize=12)\n",
    "ax1.set_title('Inference Time by Component', fontsize=14)\n",
    "ax1.tick_params(axis='x', rotation=0)\n",
    "\n",
    "# Add value labels on bars\n",
    "for bar, time_val in zip(bars, times):\n",
    "    height = bar.get_height()\n",
    "    ax1.annotate(f'{time_val:.1f}ms',\n",
    "                xy=(bar.get_x() + bar.get_width() / 2, height),\n",
    "                xytext=(0, 3),\n",
    "                textcoords=\"offset points\",\n",
    "                ha='center', va='bottom', fontsize=10)\n",
    "\n",
    "# Plot 2: Pie chart of time breakdown\n",
    "ax2 = axes[1]\n",
    "breakdown_labels = ['Data Prep', 'Backbone', 'Action Head']\n",
    "breakdown_times = [\n",
    "    np.mean(timing_results['data_prep_time']),\n",
    "    np.mean(timing_results['backbone_time']),\n",
    "    np.mean(timing_results['action_head_time'])\n",
    "]\n",
    "breakdown_colors = ['#3498db', '#e74c3c', '#9b59b6']\n",
    "\n",
    "wedges, texts, autotexts = ax2.pie(breakdown_times, labels=breakdown_labels, \n",
    "                                   autopct='%1.1f%%', colors=breakdown_colors,\n",
    "                                   explode=(0.02, 0.02, 0.02))\n",
    "ax2.set_title('E2E Time Breakdown', fontsize=14)\n",
    "\n",
    "# Plot 3: Max frequency comparison\n",
    "ax3 = axes[2]\n",
    "freq_labels = ['E2E', 'Backbone', 'Action Head']\n",
    "frequencies = [\n",
    "    1000 / (np.mean(timing_results['e2e_time']) * 1000),\n",
    "    1000 / (np.mean(timing_results['backbone_time']) * 1000),\n",
    "    1000 / (np.mean(timing_results['action_head_time']) * 1000),\n",
    "]\n",
    "freq_colors = ['#2ecc71', '#e74c3c', '#9b59b6']\n",
    "\n",
    "bars3 = ax3.bar(freq_labels, frequencies, color=freq_colors, edgecolor='black')\n",
    "ax3.set_ylabel('Frequency (Hz)', fontsize=12)\n",
    "ax3.set_title('Maximum Achievable Frequency', fontsize=14)\n",
    "\n",
    "# Add value labels on bars\n",
    "for bar, freq in zip(bars3, frequencies):\n",
    "    height = bar.get_height()\n",
    "    ax3.annotate(f'{freq:.1f} Hz',\n",
    "                xy=(bar.get_x() + bar.get_width() / 2, height),\n",
    "                xytext=(0, 3),\n",
    "                textcoords=\"offset points\",\n",
    "                ha='center', va='bottom', fontsize=10)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Detailed Denoising Steps Analysis\n",
    "\n",
    "The action head uses a flow-matching diffusion process with multiple denoising steps. Let's analyze how the number of denoising steps affects inference time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original number of denoising steps: 4\n",
      "\n",
      "Measuring action head time for different denoising steps...\n",
      "  1 steps: 24.28 +/- 1.78 ms\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  2 steps: 46.60 +/- 2.38 ms\n",
      "  4 steps: 90.98 +/- 3.11 ms\n",
      "  8 steps: 186.94 +/- 7.32 ms\n",
      "  16 steps: 363.41 +/- 6.15 ms\n"
     ]
    }
   ],
   "source": [
    "# Get current number of denoising steps\n",
    "original_num_steps = policy.model.action_head.num_inference_timesteps\n",
    "print(f\"Original number of denoising steps: {original_num_steps}\")\n",
    "\n",
    "# Test different numbers of denoising steps\n",
    "denoising_steps_to_test = [1, 2, 4, 8, 16]\n",
    "denoising_timing_results = {}\n",
    "\n",
    "# Prepare inputs once\n",
    "with torch.inference_mode():\n",
    "    collated_inputs, states = prepare_model_inputs(policy, observation)\n",
    "    backbone_inputs, action_inputs = policy.model.prepare_input(collated_inputs)\n",
    "    backbone_outputs = policy.model.backbone(backbone_inputs)\n",
    "\n",
    "print(\"\\nMeasuring action head time for different denoising steps...\")\n",
    "for num_steps in denoising_steps_to_test:\n",
    "    # Temporarily change the number of denoising steps\n",
    "    policy.model.action_head.num_inference_timesteps = num_steps\n",
    "    \n",
    "    times = []\n",
    "    for _ in range(NUM_ITERATIONS):\n",
    "        torch.cuda.synchronize()\n",
    "        start = time.perf_counter()\n",
    "        \n",
    "        with torch.inference_mode():\n",
    "            _ = policy.model.action_head.get_action(backbone_outputs, action_inputs)\n",
    "        \n",
    "        torch.cuda.synchronize()\n",
    "        end = time.perf_counter()\n",
    "        times.append(end - start)\n",
    "    \n",
    "    denoising_timing_results[num_steps] = times\n",
    "    print(f\"  {num_steps} steps: {np.mean(times)*1000:.2f} +/- {np.std(times)*1000:.2f} ms\")\n",
    "\n",
    "# Restore original number of steps\n",
    "policy.model.action_head.num_inference_timesteps = original_num_steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot denoising steps vs time\n",
    "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n",
    "\n",
    "# Plot 1: Time vs denoising steps\n",
    "ax1 = axes[0]\n",
    "steps = list(denoising_timing_results.keys())\n",
    "times = [np.mean(denoising_timing_results[s])*1000 for s in steps]\n",
    "stds = [np.std(denoising_timing_results[s])*1000 for s in steps]\n",
    "\n",
    "ax1.errorbar(steps, times, yerr=stds, fmt='o-', linewidth=2, markersize=8, capsize=5)\n",
    "ax1.set_xlabel('Number of Denoising Steps', fontsize=12)\n",
    "ax1.set_ylabel('Action Head Time (ms)', fontsize=12)\n",
    "ax1.set_title('Action Head Inference Time vs Denoising Steps', fontsize=14)\n",
    "ax1.grid(True, alpha=0.3)\n",
    "ax1.set_xticks(steps)\n",
    "\n",
    "# Add linear fit line\n",
    "z = np.polyfit(steps, times, 1)\n",
    "p = np.poly1d(z)\n",
    "ax1.plot(steps, p(steps), 'r--', alpha=0.7, label=f'Linear fit: {z[0]:.2f}ms/step')\n",
    "ax1.legend()\n",
    "\n",
    "# Plot 2: Frequency vs denoising steps\n",
    "ax2 = axes[1]\n",
    "freqs = [1000/t for t in times]\n",
    "\n",
    "ax2.bar(range(len(steps)), freqs, tick_label=[str(s) for s in steps], \n",
    "        color='#3498db', edgecolor='black')\n",
    "ax2.set_xlabel('Number of Denoising Steps', fontsize=12)\n",
    "ax2.set_ylabel('Max Action Head Frequency (Hz)', fontsize=12)\n",
    "ax2.set_title('Maximum Action Head Frequency vs Denoising Steps', fontsize=14)\n",
    "\n",
    "# Add value labels\n",
    "for i, (step, freq) in enumerate(zip(steps, freqs)):\n",
    "    ax2.annotate(f'{freq:.0f} Hz', xy=(i, freq), xytext=(0, 3),\n",
    "                textcoords=\"offset points\", ha='center', va='bottom', fontsize=10)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PyTorch Summary\n",
    "\n",
    "This section analyzed the inference timing breakdown for the GR00T model with PyTorch:\n",
    "\n",
    "### Key Findings:\n",
    "\n",
    "1. **Backbone vs Action Head Split**: The backbone (VLM) and action head (diffusion model) are the two main components of inference.\n",
    "\n",
    "2. **Denoising Steps Trade-off**: Fewer denoising steps lead to faster inference but may affect action quality."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "FINAL SUMMARY\n",
      "================================================================================\n",
      "\n",
      "Hardware: NVIDIA H100 80GB HBM3\n",
      "Model: nvidia/GR00T-N1.7-3B\n",
      "Action Horizon: 50\n",
      "Denoising Steps: 4\n",
      "\n",
      "Timing Results:\n",
      "  E2E Inference:  148.62 ms (6.7 Hz)\n",
      "  Backbone Only:  37.96 ms (26.3 Hz)\n",
      "  Action Head:    94.28 ms (10.6 Hz)\n",
      "\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "# Final summary print\n",
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"FINAL SUMMARY\")\n",
    "print(\"=\"*80)\n",
    "print(f\"\\nHardware: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'CPU'}\")\n",
    "print(f\"Model: {MODEL_PATH}\")\n",
    "print(f\"Action Horizon: {policy.model.action_head.action_horizon}\")\n",
    "print(f\"Denoising Steps: {policy.model.action_head.num_inference_timesteps}\")\n",
    "print(f\"\\nTiming Results:\")\n",
    "print(f\"  E2E Inference:  {np.mean(timing_results['e2e_time'])*1000:.2f} ms ({1000/(np.mean(timing_results['e2e_time'])*1000):.1f} Hz)\")\n",
    "print(f\"  Backbone Only:  {np.mean(timing_results['backbone_time'])*1000:.2f} ms ({1000/(np.mean(timing_results['backbone_time'])*1000):.1f} Hz)\")\n",
    "print(f\"  Action Head:    {np.mean(timing_results['action_head_time'])*1000:.2f} ms ({1000/(np.mean(timing_results['action_head_time'])*1000):.1f} Hz)\")\n",
    "print(\"\\n\" + \"=\"*80)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## torch.compile Inference Timing\n",
    "\n",
    "PyTorch 2.0+ provides `torch.compile()` which can significantly accelerate model inference through graph optimization and kernel fusion. Let's measure the performance with `torch.compile` using `max-autotune` mode.\n",
    "\n",
    "**Note:** The first inference after compilation will be slower due to JIT compilation overhead. We account for this with additional warmup iterations.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading fresh policy for torch.compile...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tune backbone llm: False\n",
      "Tune backbone visual: False\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.self_attn.q_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.self_attn.k_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.self_attn.v_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.self_attn.o_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.self_attn.q_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.self_attn.k_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.mlp.gate_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.mlp.up_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.mlp.down_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.input_layernorm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.post_attention_layernorm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.self_attn.q_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.self_attn.k_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.self_attn.v_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.self_attn.o_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.self_attn.q_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.self_attn.k_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.mlp.gate_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.mlp.up_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.mlp.down_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.input_layernorm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.post_attention_layernorm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.self_attn.q_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.self_attn.k_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.self_attn.v_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.self_attn.o_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.self_attn.q_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.self_attn.k_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.mlp.gate_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.mlp.up_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.mlp.down_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.input_layernorm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.post_attention_layernorm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.self_attn.q_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.self_attn.k_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.self_attn.v_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.self_attn.o_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.self_attn.q_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.self_attn.k_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.mlp.gate_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.mlp.up_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.mlp.down_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.input_layernorm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.post_attention_layernorm.weight\n",
      "Casting trainable parameter model.language_model.model.layers.12.self_attn.q_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.self_attn.k_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.self_attn.v_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.self_attn.o_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.self_attn.q_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.self_attn.k_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.mlp.gate_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.mlp.up_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.mlp.down_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.input_layernorm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.post_attention_layernorm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.self_attn.q_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.self_attn.k_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.self_attn.v_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.self_attn.o_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.self_attn.q_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.self_attn.k_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.mlp.gate_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.mlp.up_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.mlp.down_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.input_layernorm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.post_attention_layernorm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.self_attn.q_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.self_attn.k_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.self_attn.v_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.self_attn.o_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.self_attn.q_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.self_attn.k_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.mlp.gate_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.mlp.up_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.mlp.down_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.input_layernorm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.post_attention_layernorm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.self_attn.q_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.self_attn.k_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.self_attn.v_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.self_attn.o_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.self_attn.q_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.self_attn.k_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.mlp.gate_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.mlp.up_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.mlp.down_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.input_layernorm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.post_attention_layernorm.weight to fp32\n",
      "Total number of DiT parameters:  1091722240\n",
      "Using AlternateVLDiT for diffusion model\n",
      "Tune action head projector: True\n",
      "Tune action head diffusion model: True\n",
      "Tune action head vlln: True\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading checkpoint shards: 100%|██████████| 2/2 [00:02<00:00,  1.24s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Applying torch.compile with mode='max-autotune'...\n",
      "torch.compile policy ready!\n"
     ]
    }
   ],
   "source": [
    "# Load a fresh policy for torch.compile\n",
    "print(\"Loading fresh policy for torch.compile...\")\n",
    "policy_compiled = Gr00tPolicy(\n",
    "    model_path=MODEL_PATH,\n",
    "    embodiment_tag=EmbodimentTag.resolve(EMBODIMENT_TAG),\n",
    "    device=device,\n",
    "    strict=True,\n",
    ")\n",
    "\n",
    "# Apply torch.compile with max-autotune mode\n",
    "print(\"Applying torch.compile with mode='max-autotune'...\")\n",
    "policy_compiled.model.action_head.model.forward = torch.compile(policy_compiled.model.action_head.model.forward, mode=\"max-autotune\")\n",
    "\n",
    "# Enable cuDNN benchmark for additional optimization\n",
    "if torch.cuda.is_available():\n",
    "    torch.backends.cudnn.benchmark = True\n",
    "\n",
    "print(\"torch.compile policy ready!\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running torch.compile warmup iterations (this may take a while due to JIT compilation)...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  First inference complete (JIT compilation triggered)\n",
      "torch.compile warmup complete!\n"
     ]
    }
   ],
   "source": [
    "# Warmup runs for torch.compile - extra iterations needed for JIT compilation\n",
    "print(\"Running torch.compile warmup iterations (this may take a while due to JIT compilation)...\")\n",
    "for i in range(5):  # More warmup iterations for torch.compile\n",
    "    with torch.inference_mode():\n",
    "        _ = policy_compiled.get_action(observation)\n",
    "    if i == 0:\n",
    "        print(\"  First inference complete (JIT compilation triggered)\")\n",
    "torch.cuda.synchronize()\n",
    "print(\"torch.compile warmup complete!\")\n",
    "\n",
    "# Storage for torch.compile timing results\n",
    "compile_timing_results = {\n",
    "    \"e2e_time\": [],\n",
    "    \"data_prep_time\": [],\n",
    "    \"backbone_time\": [],\n",
    "    \"action_head_time\": [],\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measure torch.compile E2E Inference Time\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measuring torch.compile full E2E inference time...\n",
      "torch.compile E2E inference time: 69.38 ± 30.01 ms\n"
     ]
    }
   ],
   "source": [
    "print(\"Measuring torch.compile full E2E inference time...\")\n",
    "for i in range(NUM_ITERATIONS):\n",
    "    torch.cuda.synchronize()\n",
    "    start = time.perf_counter()\n",
    "    \n",
    "    with torch.inference_mode():\n",
    "        action, _ = policy_compiled.get_action(observation)\n",
    "    \n",
    "    torch.cuda.synchronize()\n",
    "    end = time.perf_counter()\n",
    "    compile_timing_results[\"e2e_time\"].append(end - start)\n",
    "\n",
    "e2e_mean = np.mean(compile_timing_results[\"e2e_time\"]) * 1000\n",
    "e2e_std = np.std(compile_timing_results[\"e2e_time\"]) * 1000\n",
    "print(f\"torch.compile E2E inference time: {e2e_mean:.2f} ± {e2e_std:.2f} ms\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measure torch.compile Component-wise Inference Time\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measuring torch.compile component-wise inference time...\n",
      "  (Using shared data preparation timing from PyTorch Eager benchmark)\n",
      "\n",
      "torch.compile Component-wise timing (averaged over 20 iterations):\n",
      "  Data preparation:     4.72 ± 0.72 ms (shared)\n",
      "  Backbone:             36.71 ± 1.44 ms\n",
      "  Action head:          12.56 ± 0.07 ms\n"
     ]
    }
   ],
   "source": [
    "# Note: torch.compile optimizes the entire model graph, so component-wise timing\n",
    "# may not reflect the same optimizations as the E2E measurement.\n",
    "# However, we measure them for comparison purposes.\n",
    "\n",
    "# Data preparation is the same regardless of inference mode (torch.compile doesn't affect it)\n",
    "# Use the shared data preparation timing from PyTorch Eager benchmark for consistency\n",
    "compile_timing_results[\"data_prep_time\"] = timing_results[\"data_prep_time\"].copy()\n",
    "\n",
    "print(\"Measuring torch.compile component-wise inference time...\")\n",
    "print(\"  (Using shared data preparation timing from PyTorch Eager benchmark)\")\n",
    "\n",
    "for i in range(NUM_ITERATIONS):\n",
    "    collated_inputs, states = prepare_model_inputs(policy_compiled, observation)\n",
    "    \n",
    "    # 1. Backbone timing\n",
    "    torch.cuda.synchronize()\n",
    "    start_backbone = time.perf_counter()\n",
    "    \n",
    "    with torch.inference_mode():\n",
    "        backbone_inputs, action_inputs = policy_compiled.model.prepare_input(collated_inputs)\n",
    "        backbone_outputs = policy_compiled.model.backbone(backbone_inputs)\n",
    "    \n",
    "    torch.cuda.synchronize()\n",
    "    end_backbone = time.perf_counter()\n",
    "    compile_timing_results[\"backbone_time\"].append(end_backbone - start_backbone)\n",
    "    \n",
    "    # 2. Action head timing\n",
    "    torch.cuda.synchronize()\n",
    "    start_action = time.perf_counter()\n",
    "    \n",
    "    with torch.inference_mode():\n",
    "        action_outputs = policy_compiled.model.action_head.get_action(backbone_outputs, action_inputs)\n",
    "    \n",
    "    torch.cuda.synchronize()\n",
    "    end_action = time.perf_counter()\n",
    "    compile_timing_results[\"action_head_time\"].append(end_action - start_action)\n",
    "\n",
    "print(f\"\\ntorch.compile Component-wise timing (averaged over {NUM_ITERATIONS} iterations):\")\n",
    "print(f\"  Data preparation:     {np.mean(compile_timing_results['data_prep_time'])*1000:.2f} ± {np.std(compile_timing_results['data_prep_time'])*1000:.2f} ms (shared)\")\n",
    "print(f\"  Backbone:             {np.mean(compile_timing_results['backbone_time'])*1000:.2f} ± {np.std(compile_timing_results['backbone_time'])*1000:.2f} ms\")\n",
    "print(f\"  Action head:          {np.mean(compile_timing_results['action_head_time'])*1000:.2f} ± {np.std(compile_timing_results['action_head_time'])*1000:.2f} ms\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PyTorch (Eager) vs torch.compile Comparison\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "====================================================================================================\n",
      "PYTORCH EAGER vs torch.compile COMPARISON\n",
      "====================================================================================================\n",
      "         Component  PyTorch Eager (ms)  torch.compile (ms)  Speedup  Eager (Hz)  Compiled (Hz)\n",
      "Full E2E Inference              148.62               69.38     2.14        6.73          14.41\n",
      "  Data Preparation                4.72                4.72     1.00      211.85         211.85\n",
      "    Backbone (VLM)               37.96               36.71     1.03       26.34          27.24\n",
      "       Action Head               94.28               12.56     7.50       10.61          79.59\n",
      "\n",
      "====================================================================================================\n",
      "KEY INSIGHTS\n",
      "====================================================================================================\n",
      "\n",
      "✓ E2E Speedup: 2.14x faster with torch.compile\n",
      "✓ Action Head Speedup: 7.50x faster with torch.compile\n",
      "✓ Backbone Speedup: 1.03x faster with torch.compile\n",
      "\n",
      "✓ E2E Frequency: 6.7 Hz (Eager) → 14.4 Hz (Compiled)\n"
     ]
    }
   ],
   "source": [
    "# Create comparison DataFrame: PyTorch Eager vs torch.compile\n",
    "compile_comparison_data = {\n",
    "    \"Component\": [\n",
    "        \"Full E2E Inference\",\n",
    "        \"Data Preparation\",\n",
    "        \"Backbone (VLM)\",\n",
    "        \"Action Head\",\n",
    "    ],\n",
    "    \"PyTorch Eager (ms)\": [\n",
    "        np.mean(timing_results[\"e2e_time\"]) * 1000,\n",
    "        np.mean(timing_results[\"data_prep_time\"]) * 1000,\n",
    "        np.mean(timing_results[\"backbone_time\"]) * 1000,\n",
    "        np.mean(timing_results[\"action_head_time\"]) * 1000,\n",
    "    ],\n",
    "    \"torch.compile (ms)\": [\n",
    "        np.mean(compile_timing_results[\"e2e_time\"]) * 1000,\n",
    "        np.mean(compile_timing_results[\"data_prep_time\"]) * 1000,\n",
    "        np.mean(compile_timing_results[\"backbone_time\"]) * 1000,\n",
    "        np.mean(compile_timing_results[\"action_head_time\"]) * 1000,\n",
    "    ],\n",
    "}\n",
    "\n",
    "# Calculate speedup\n",
    "compile_comparison_data[\"Speedup\"] = [\n",
    "    compile_comparison_data[\"PyTorch Eager (ms)\"][i] / compile_comparison_data[\"torch.compile (ms)\"][i] \n",
    "    if compile_comparison_data[\"torch.compile (ms)\"][i] > 0 else 0\n",
    "    for i in range(len(compile_comparison_data[\"Component\"]))\n",
    "]\n",
    "\n",
    "# Calculate max frequency\n",
    "compile_comparison_data[\"Eager (Hz)\"] = [1000 / t if t > 0 else 0 for t in compile_comparison_data[\"PyTorch Eager (ms)\"]]\n",
    "compile_comparison_data[\"Compiled (Hz)\"] = [1000 / t if t > 0 else 0 for t in compile_comparison_data[\"torch.compile (ms)\"]]\n",
    "\n",
    "df_compile_comparison = pd.DataFrame(compile_comparison_data)\n",
    "\n",
    "print(\"\\n\" + \"=\"*100)\n",
    "print(\"PYTORCH EAGER vs torch.compile COMPARISON\")\n",
    "print(\"=\"*100)\n",
    "print(df_compile_comparison.to_string(index=False, float_format=lambda x: f\"{x:.2f}\"))\n",
    "\n",
    "print(\"\\n\" + \"=\"*100)\n",
    "print(\"KEY INSIGHTS\")\n",
    "print(\"=\"*100)\n",
    "\n",
    "# E2E speedup\n",
    "e2e_speedup = compile_comparison_data[\"PyTorch Eager (ms)\"][0] / compile_comparison_data[\"torch.compile (ms)\"][0]\n",
    "print(f\"\\n✓ E2E Speedup: {e2e_speedup:.2f}x {'faster' if e2e_speedup > 1 else 'slower'} with torch.compile\")\n",
    "\n",
    "# Action head speedup\n",
    "ah_speedup = compile_comparison_data[\"PyTorch Eager (ms)\"][3] / compile_comparison_data[\"torch.compile (ms)\"][3]\n",
    "print(f\"✓ Action Head Speedup: {ah_speedup:.2f}x {'faster' if ah_speedup > 1 else 'slower'} with torch.compile\")\n",
    "\n",
    "# Backbone speedup\n",
    "bb_speedup = compile_comparison_data[\"PyTorch Eager (ms)\"][2] / compile_comparison_data[\"torch.compile (ms)\"][2]\n",
    "print(f\"✓ Backbone Speedup: {bb_speedup:.2f}x {'faster' if bb_speedup > 1 else 'slower'} with torch.compile\")\n",
    "\n",
    "# Frequency improvement\n",
    "eager_hz = 1000 / compile_comparison_data[\"PyTorch Eager (ms)\"][0]\n",
    "compiled_hz = 1000 / compile_comparison_data[\"torch.compile (ms)\"][0]\n",
    "print(f\"\\n✓ E2E Frequency: {eager_hz:.1f} Hz (Eager) → {compiled_hz:.1f} Hz (Compiled)\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### torch.compile Visualization\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, 3, figsize=(16, 5))\n",
    "\n",
    "# Plot 1: Side-by-side bar chart of inference times\n",
    "ax1 = axes[0]\n",
    "components = [\"E2E\", \"Backbone\", \"Action Head\"]\n",
    "eager_times = [\n",
    "    np.mean(timing_results[\"e2e_time\"]) * 1000,\n",
    "    np.mean(timing_results[\"backbone_time\"]) * 1000,\n",
    "    np.mean(timing_results[\"action_head_time\"]) * 1000,\n",
    "]\n",
    "compiled_times = [\n",
    "    np.mean(compile_timing_results[\"e2e_time\"]) * 1000,\n",
    "    np.mean(compile_timing_results[\"backbone_time\"]) * 1000,\n",
    "    np.mean(compile_timing_results[\"action_head_time\"]) * 1000,\n",
    "]\n",
    "\n",
    "x = np.arange(len(components))\n",
    "width = 0.35\n",
    "\n",
    "bars1 = ax1.bar(x - width/2, eager_times, width, label='PyTorch Eager', color='#3498db', edgecolor='black')\n",
    "bars2 = ax1.bar(x + width/2, compiled_times, width, label='torch.compile', color='#27ae60', edgecolor='black')\n",
    "\n",
    "ax1.set_ylabel('Time (ms)', fontsize=12)\n",
    "ax1.set_title('PyTorch Eager vs torch.compile', fontsize=14)\n",
    "ax1.set_xticks(x)\n",
    "ax1.set_xticklabels(components)\n",
    "ax1.legend()\n",
    "ax1.grid(axis='y', alpha=0.3)\n",
    "\n",
    "# Add value labels\n",
    "for bar, val in zip(bars1, eager_times):\n",
    "    ax1.annotate(f'{val:.1f}', xy=(bar.get_x() + bar.get_width()/2, bar.get_height()),\n",
    "                xytext=(0, 3), textcoords=\"offset points\", ha='center', va='bottom', fontsize=9)\n",
    "for bar, val in zip(bars2, compiled_times):\n",
    "    ax1.annotate(f'{val:.1f}', xy=(bar.get_x() + bar.get_width()/2, bar.get_height()),\n",
    "                xytext=(0, 3), textcoords=\"offset points\", ha='center', va='bottom', fontsize=9)\n",
    "\n",
    "# Plot 2: Speedup bar chart\n",
    "ax2 = axes[1]\n",
    "speedups = [eager_times[i] / compiled_times[i] if compiled_times[i] > 0 else 0 for i in range(len(components))]\n",
    "colors_speedup = ['#27ae60' if s > 1 else '#e74c3c' for s in speedups]\n",
    "\n",
    "bars3 = ax2.bar(components, speedups, color=colors_speedup, edgecolor='black')\n",
    "ax2.axhline(y=1, color='black', linestyle='--', linewidth=1, label='No speedup')\n",
    "ax2.set_ylabel('Speedup (x)', fontsize=12)\n",
    "ax2.set_title('torch.compile Speedup over Eager', fontsize=14)\n",
    "ax2.grid(axis='y', alpha=0.3)\n",
    "\n",
    "for bar, val in zip(bars3, speedups):\n",
    "    ax2.annotate(f'{val:.2f}x', xy=(bar.get_x() + bar.get_width()/2, bar.get_height()),\n",
    "                xytext=(0, 3), textcoords=\"offset points\", ha='center', va='bottom', fontsize=10, fontweight='bold')\n",
    "\n",
    "# Plot 3: Max frequency comparison\n",
    "ax3 = axes[2]\n",
    "eager_freqs = [1000/t if t > 0 else 0 for t in eager_times]\n",
    "compiled_freqs = [1000/t if t > 0 else 0 for t in compiled_times]\n",
    "\n",
    "bars4 = ax3.bar(x - width/2, eager_freqs, width, label='PyTorch Eager', color='#3498db', edgecolor='black')\n",
    "bars5 = ax3.bar(x + width/2, compiled_freqs, width, label='torch.compile', color='#27ae60', edgecolor='black')\n",
    "\n",
    "ax3.set_ylabel('Frequency (Hz)', fontsize=12)\n",
    "ax3.set_title('Maximum Achievable Frequency', fontsize=14)\n",
    "ax3.set_xticks(x)\n",
    "ax3.set_xticklabels(components)\n",
    "ax3.legend()\n",
    "ax3.grid(axis='y', alpha=0.3)\n",
    "\n",
    "for bar, val in zip(bars4, eager_freqs):\n",
    "    ax3.annotate(f'{val:.0f}', xy=(bar.get_x() + bar.get_width()/2, bar.get_height()),\n",
    "                xytext=(0, 3), textcoords=\"offset points\", ha='center', va='bottom', fontsize=9)\n",
    "for bar, val in zip(bars5, compiled_freqs):\n",
    "    ax3.annotate(f'{val:.0f}', xy=(bar.get_x() + bar.get_width()/2, bar.get_height()),\n",
    "                xytext=(0, 3), textcoords=\"offset points\", ha='center', va='bottom', fontsize=9)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### torch.compile Summary\n",
    "\n",
    "`torch.compile` with `max-autotune` mode provides JIT compilation optimizations:\n",
    "\n",
    "**Key Benefits:**\n",
    "- **Zero setup overhead**: No need to export ONNX or build TensorRT engines\n",
    "- **Graph optimizations**: Operator fusion and memory planning\n",
    "- **Kernel optimization**: Auto-tuning for the specific hardware\n",
    "\n",
    "**Trade-offs:**\n",
    "- **First inference is slow**: JIT compilation happens on first run\n",
    "- **Less speedup than TensorRT**: TensorRT typically provides greater acceleration for the DiT action head"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TensorRT Inference Timing\n",
    "\n",
    "Now let's compare the PyTorch inference with TensorRT. TensorRT accelerates the DiT (Diffusion Transformer) action head, which is the main computational bottleneck.\n",
    "\n",
    "**Setup Requirements:**\n",
    "- TensorRT engine built from ONNX export: `~/tensorrt-engine/dit_model_bf16.trt`\n",
    "- Built using: `python scripts/deployment/build_tensorrt_engine.py`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TensorRT Engine Path\n",
    "TRT_ENGINE_PATH = os.path.expanduser(\"~/tensorrt-engine/dit_model_bf16.trt\")\n",
    "\n",
    "# Check if TensorRT engine exists\n",
    "if os.path.exists(TRT_ENGINE_PATH):\n",
    "    print(f\"✓ TensorRT engine found: {TRT_ENGINE_PATH}\")\n",
    "    print(f\"  Size: {os.path.getsize(TRT_ENGINE_PATH) / (1024**2):.2f} MB\")\n",
    "    TRT_AVAILABLE = True\n",
    "else:\n",
    "    print(f\"✗ TensorRT engine not found at: {TRT_ENGINE_PATH}\")\n",
    "    print(\"  To build the engine, run:\")\n",
    "    print(\"  python scripts/deployment/export_onnx_n1d7.py --model-path nvidia/GR00T-N1.7-3B --dataset-path <dataset> --output-dir ./gr00t_n1d7_onnx\")\n",
    "    print(\"  python scripts/deployment/build_tensorrt_engine.py --onnx ./gr00t_n1d7_onnx/dit_bf16.onnx --engine ~/tensorrt-engine/dit_model_bf16.trt --precision bf16\")\n",
    "    TRT_AVAILABLE = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import TensorRT utilities from deployment module (same directory)\n",
    "from standalone_inference_script import (\n",
    "    TensorRTDiTWrapper,\n",
    "    replace_dit_with_tensorrt,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading fresh policy for TensorRT...\n",
      "Tune backbone llm: False\n",
      "Tune backbone visual: False\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.self_attn.q_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.self_attn.k_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.self_attn.v_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.self_attn.o_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.self_attn.q_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.self_attn.k_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.mlp.gate_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.mlp.up_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.mlp.down_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.input_layernorm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.12.post_attention_layernorm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.self_attn.q_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.self_attn.k_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.self_attn.v_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.self_attn.o_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.self_attn.q_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.self_attn.k_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.mlp.gate_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.mlp.up_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.mlp.down_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.input_layernorm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.13.post_attention_layernorm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.self_attn.q_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.self_attn.k_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.self_attn.v_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.self_attn.o_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.self_attn.q_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.self_attn.k_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.mlp.gate_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.mlp.up_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.mlp.down_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.input_layernorm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.14.post_attention_layernorm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.self_attn.q_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.self_attn.k_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.self_attn.v_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.self_attn.o_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.self_attn.q_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.self_attn.k_norm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.mlp.gate_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.mlp.up_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.mlp.down_proj.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.input_layernorm.weight\n",
      "Backbone trainable parameter: model.language_model.model.layers.15.post_attention_layernorm.weight\n",
      "Casting trainable parameter model.language_model.model.layers.12.self_attn.q_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.self_attn.k_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.self_attn.v_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.self_attn.o_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.self_attn.q_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.self_attn.k_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.mlp.gate_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.mlp.up_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.mlp.down_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.input_layernorm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.12.post_attention_layernorm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.self_attn.q_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.self_attn.k_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.self_attn.v_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.self_attn.o_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.self_attn.q_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.self_attn.k_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.mlp.gate_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.mlp.up_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.mlp.down_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.input_layernorm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.13.post_attention_layernorm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.self_attn.q_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.self_attn.k_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.self_attn.v_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.self_attn.o_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.self_attn.q_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.self_attn.k_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.mlp.gate_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.mlp.up_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.mlp.down_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.input_layernorm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.14.post_attention_layernorm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.self_attn.q_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.self_attn.k_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.self_attn.v_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.self_attn.o_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.self_attn.q_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.self_attn.k_norm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.mlp.gate_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.mlp.up_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.mlp.down_proj.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.input_layernorm.weight to fp32\n",
      "Casting trainable parameter model.language_model.model.layers.15.post_attention_layernorm.weight to fp32\n",
      "Total number of DiT parameters:  1091722240\n",
      "Using AlternateVLDiT for diffusion model\n",
      "Tune action head projector: True\n",
      "Tune action head diffusion model: True\n",
      "Tune action head vlln: True\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading checkpoint shards: 100%|██████████| 2/2 [00:01<00:00,  1.04it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "TensorRT policy ready!\n"
     ]
    }
   ],
   "source": [
    "if TRT_AVAILABLE:\n",
    "    # Free the torch.compile policy before loading the TensorRT policy.\n",
    "    # Keeping the eager, torch.compile, and TensorRT policies resident at\n",
    "    # once can exceed GPU memory on smaller cards (e.g. NVIDIA A16, 15 GB)\n",
    "    # and raise a CUDA OutOfMemoryError here. Only the compiled policy's\n",
    "    # numeric timing results are needed later, so its object can be freed.\n",
    "    import gc\n",
    "\n",
    "    if \"policy_compiled\" in globals():\n",
    "        del globals()[\"policy_compiled\"]\n",
    "    gc.collect()\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "    # Load a fresh policy for TensorRT\n",
    "    print(\"Loading fresh policy for TensorRT...\")\n",
    "    policy_trt = Gr00tPolicy(\n",
    "        model_path=MODEL_PATH,\n",
    "        embodiment_tag=EmbodimentTag.resolve(EMBODIMENT_TAG),\n",
    "        device=device,\n",
    "        strict=True,\n",
    "    )\n",
    "    \n",
    "    # Replace DiT with TensorRT engine\n",
    "    replace_dit_with_tensorrt(policy_trt, TRT_ENGINE_PATH)\n",
    "    print(f\"\\nTensorRT policy ready!\")\n",
    "else:\n",
    "    print(\"Skipping TensorRT setup - engine not available\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running TensorRT warmup iterations...\n",
      "[12/11/2025-13:09:19] [TRT] [W] Using default stream in enqueueV3() may lead to performance issues due to additional calls to cudaStreamSynchronize() by TensorRT to ensure correct synchronization. Please use non-default stream instead.\n",
      "TensorRT warmup complete!\n"
     ]
    }
   ],
   "source": [
    "if TRT_AVAILABLE:\n",
    "    # Warmup runs for TensorRT\n",
    "    print(\"Running TensorRT warmup iterations...\")\n",
    "    for _ in range(3):\n",
    "        with torch.inference_mode():\n",
    "            _ = policy_trt.get_action(observation)\n",
    "    torch.cuda.synchronize()\n",
    "    print(\"TensorRT warmup complete!\")\n",
    "    \n",
    "    # Storage for TensorRT timing results\n",
    "    trt_timing_results = {\n",
    "        \"e2e_time\": [],\n",
    "        \"data_prep_time\": [],\n",
    "        \"backbone_time\": [],\n",
    "        \"action_head_time\": [],\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measure TensorRT E2E Inference Time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measuring TensorRT full E2E inference time...\n",
      "TensorRT E2E inference time: 54.59 ± 9.11 ms\n"
     ]
    }
   ],
   "source": [
    "if TRT_AVAILABLE:\n",
    "    print(\"Measuring TensorRT full E2E inference time...\")\n",
    "    for i in range(NUM_ITERATIONS):\n",
    "        torch.cuda.synchronize()\n",
    "        start = time.perf_counter()\n",
    "        \n",
    "        with torch.inference_mode():\n",
    "            action, _ = policy_trt.get_action(observation)\n",
    "        \n",
    "        torch.cuda.synchronize()\n",
    "        end = time.perf_counter()\n",
    "        trt_timing_results[\"e2e_time\"].append(end - start)\n",
    "\n",
    "    e2e_mean = np.mean(trt_timing_results[\"e2e_time\"]) * 1000\n",
    "    e2e_std = np.std(trt_timing_results[\"e2e_time\"]) * 1000\n",
    "    print(f\"TensorRT E2E inference time: {e2e_mean:.2f} ± {e2e_std:.2f} ms\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measure TensorRT Component-wise Inference Time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measuring TensorRT component-wise inference time...\n",
      "  (Using shared data preparation timing from PyTorch Eager benchmark)\n",
      "\n",
      "TensorRT Component-wise timing (averaged over 20 iterations):\n",
      "  Data preparation: 4.72 ± 0.72 ms (shared)\n",
      "  Backbone:         35.84 ± 0.98 ms\n",
      "  Action head (TRT):10.39 ± 0.03 ms\n"
     ]
    }
   ],
   "source": [
    "if TRT_AVAILABLE:\n",
    "    # Data preparation is the same regardless of inference mode (TensorRT doesn't affect it)\n",
    "    # Use the shared data preparation timing from PyTorch Eager benchmark for consistency\n",
    "    trt_timing_results[\"data_prep_time\"] = timing_results[\"data_prep_time\"].copy()\n",
    "    \n",
    "    print(\"Measuring TensorRT component-wise inference time...\")\n",
    "    print(\"  (Using shared data preparation timing from PyTorch Eager benchmark)\")\n",
    "\n",
    "    for i in range(NUM_ITERATIONS):\n",
    "        collated_inputs, states = prepare_model_inputs(policy_trt, observation)\n",
    "        \n",
    "        # 1. Backbone timing (same as PyTorch - backbone is not replaced)\n",
    "        torch.cuda.synchronize()\n",
    "        start_backbone = time.perf_counter()\n",
    "        \n",
    "        with torch.inference_mode():\n",
    "            backbone_inputs, action_inputs = policy_trt.model.prepare_input(collated_inputs)\n",
    "            backbone_outputs = policy_trt.model.backbone(backbone_inputs)\n",
    "        \n",
    "        torch.cuda.synchronize()\n",
    "        end_backbone = time.perf_counter()\n",
    "        trt_timing_results[\"backbone_time\"].append(end_backbone - start_backbone)\n",
    "        \n",
    "        # 2. Action head timing (using TensorRT DiT)\n",
    "        torch.cuda.synchronize()\n",
    "        start_action = time.perf_counter()\n",
    "        \n",
    "        with torch.inference_mode():\n",
    "            action_outputs = policy_trt.model.action_head.get_action(backbone_outputs, action_inputs)\n",
    "        \n",
    "        torch.cuda.synchronize()\n",
    "        end_action = time.perf_counter()\n",
    "        trt_timing_results[\"action_head_time\"].append(end_action - start_action)\n",
    "\n",
    "    print(f\"\\nTensorRT Component-wise timing (averaged over {NUM_ITERATIONS} iterations):\")\n",
    "    print(f\"  Data preparation: {np.mean(trt_timing_results['data_prep_time'])*1000:.2f} ± {np.std(trt_timing_results['data_prep_time'])*1000:.2f} ms (shared)\")\n",
    "    print(f\"  Backbone:         {np.mean(trt_timing_results['backbone_time'])*1000:.2f} ± {np.std(trt_timing_results['backbone_time'])*1000:.2f} ms\")\n",
    "    print(f\"  Action head (TRT):{np.mean(trt_timing_results['action_head_time'])*1000:.2f} ± {np.std(trt_timing_results['action_head_time'])*1000:.2f} ms\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PyTorch vs TensorRT Comparison\n",
    "\n",
    "Now let's compare the timing results between PyTorch and TensorRT side by side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "====================================================================================================\n",
      "PYTORCH vs TENSORRT COMPARISON\n",
      "====================================================================================================\n",
      "         Component  PyTorch (ms)  TensorRT (ms)  Speedup  PyTorch (Hz)  TensorRT (Hz)\n",
      "Full E2E Inference        148.62          54.59     2.72          6.73          18.32\n",
      "  Data Preparation          4.72           4.72     1.00        211.85         211.85\n",
      "    Backbone (VLM)         37.96          35.84     1.06         26.34          27.90\n",
      "       Action Head         94.28          10.39     9.08         10.61          96.27\n",
      "\n",
      "====================================================================================================\n",
      "KEY INSIGHTS\n",
      "====================================================================================================\n",
      "\n",
      "✓ E2E Speedup: 2.72x faster with TensorRT\n",
      "✓ Action Head Speedup: 9.08x faster with TensorRT\n",
      "\n",
      "✓ Time saved per inference: 94.03 ms\n",
      "✓ E2E Frequency: 6.7 Hz (PyTorch) → 18.3 Hz (TensorRT)\n"
     ]
    }
   ],
   "source": [
    "if TRT_AVAILABLE:\n",
    "    # Create comparison DataFrame\n",
    "    comparison_data = {\n",
    "        \"Component\": [\n",
    "            \"Full E2E Inference\",\n",
    "            \"Data Preparation\",\n",
    "            \"Backbone (VLM)\",\n",
    "            \"Action Head\",\n",
    "        ],\n",
    "        \"PyTorch (ms)\": [\n",
    "            np.mean(timing_results[\"e2e_time\"]) * 1000,\n",
    "            np.mean(timing_results[\"data_prep_time\"]) * 1000,\n",
    "            np.mean(timing_results[\"backbone_time\"]) * 1000,\n",
    "            np.mean(timing_results[\"action_head_time\"]) * 1000,\n",
    "        ],\n",
    "        \"TensorRT (ms)\": [\n",
    "            np.mean(trt_timing_results[\"e2e_time\"]) * 1000,\n",
    "            np.mean(trt_timing_results[\"data_prep_time\"]) * 1000,\n",
    "            np.mean(trt_timing_results[\"backbone_time\"]) * 1000,\n",
    "            np.mean(trt_timing_results[\"action_head_time\"]) * 1000,\n",
    "        ],\n",
    "    }\n",
    "    \n",
    "    # Calculate speedup\n",
    "    comparison_data[\"Speedup\"] = [\n",
    "        comparison_data[\"PyTorch (ms)\"][i] / comparison_data[\"TensorRT (ms)\"][i] \n",
    "        if comparison_data[\"TensorRT (ms)\"][i] > 0 else 0\n",
    "        for i in range(len(comparison_data[\"Component\"]))\n",
    "    ]\n",
    "    \n",
    "    # Calculate max frequency\n",
    "    comparison_data[\"PyTorch (Hz)\"] = [1000 / t if t > 0 else 0 for t in comparison_data[\"PyTorch (ms)\"]]\n",
    "    comparison_data[\"TensorRT (Hz)\"] = [1000 / t if t > 0 else 0 for t in comparison_data[\"TensorRT (ms)\"]]\n",
    "\n",
    "    df_comparison = pd.DataFrame(comparison_data)\n",
    "    \n",
    "    print(\"\\n\" + \"=\"*100)\n",
    "    print(\"PYTORCH vs TENSORRT COMPARISON\")\n",
    "    print(\"=\"*100)\n",
    "    print(df_comparison.to_string(index=False, float_format=lambda x: f\"{x:.2f}\"))\n",
    "    \n",
    "    print(\"\\n\" + \"=\"*100)\n",
    "    print(\"KEY INSIGHTS\")\n",
    "    print(\"=\"*100)\n",
    "    \n",
    "    # E2E speedup\n",
    "    e2e_speedup = comparison_data[\"PyTorch (ms)\"][0] / comparison_data[\"TensorRT (ms)\"][0]\n",
    "    print(f\"\\n✓ E2E Speedup: {e2e_speedup:.2f}x faster with TensorRT\")\n",
    "    \n",
    "    # Action head speedup (the main optimization target)\n",
    "    ah_speedup = comparison_data[\"PyTorch (ms)\"][3] / comparison_data[\"TensorRT (ms)\"][3]\n",
    "    print(f\"✓ Action Head Speedup: {ah_speedup:.2f}x faster with TensorRT\")\n",
    "    \n",
    "    # Time saved\n",
    "    time_saved = comparison_data[\"PyTorch (ms)\"][0] - comparison_data[\"TensorRT (ms)\"][0]\n",
    "    print(f\"\\n✓ Time saved per inference: {time_saved:.2f} ms\")\n",
    "    \n",
    "    # Frequency improvement\n",
    "    pytorch_hz = 1000 / comparison_data[\"PyTorch (ms)\"][0]\n",
    "    trt_hz = 1000 / comparison_data[\"TensorRT (ms)\"][0]\n",
    "    print(f\"✓ E2E Frequency: {pytorch_hz:.1f} Hz (PyTorch) → {trt_hz:.1f} Hz (TensorRT)\")\n",
    "else:\n",
    "    print(\"TensorRT comparison not available - engine not found\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PyTorch vs TensorRT Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABjUAAASlCAYAAADgeltjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XlcVGX///H3DCiLyqIogoKS+65hueZepmmalrmGS66571YumGWWmtutpt7uWt3ddZtaWmrmllpilPsSqIUrKaIhqMz5/eGP+TYBCjgwDr2ejwePB3Od61znc2ZQzuF9znVMhmEYAgAAAAAAAAAAeMSZHV0AAAAAAAAAAABARhBqAAAAAAAAAAAAp0CoAQAAAAAAAAAAnAKhBgAAAAAAAAAAcAqEGgAAAAAAAAAAwCkQagAAAAAAAAAAAKdAqAEAAAAAAAAAAJwCoQYAAAAAAAAAAHAKhBoAAAAAAAAAAMApEGoA+McwmUxq1KiRo8vAP8ydO3c0adIklSlTRm5ubjKZTFq3bp2jy8qVGjVqJJPJ5OgyAAAA4ARKliypkiVLOroM5BLdu3eXyWTSmTNnHF0K8I9AqAH8w5w5c0Ymk8nmK2/evAoKClLnzp31yy+/ZGnckiVLphr3fl/8on+w5cuXZ+o97d69u6NLtru03gMPDw+VLVtWgwYN0sWLFyWl/XN9v6+MnLyYTCaVL1/+ofdhxowZCg8PV2BgoEaOHKmJEyfaZdzcLjOfJ0EGAAC5F8cEqd8DV1dX+fv7q1WrVtq6dau1X8oFHhn9+u677x647T179uill15SsWLFlDdvXvn6+qp8+fLq3LmzVqxYkY17DWf1959Ds9ksX19fPfXUU1q+fLkMw8j0mJMmTcrUz/akSZPsv2MAHimuji4AgGOUKlVKXbt2lSTdvHlT+/bt00cffaTPP/9c27ZtU7169TI13tChQxUXF2fTtnz5cp09e1ZDhgyRj4+PzbK/v0Zq1atX18SJE23azpw5oxUrVqhatWpq27Ztqv65VdOmTVW/fn1J0h9//KFt27Zp3rx5WrdunQ4ePCgfH59U75UkhYeHy9vbW0OHDrVpz8mfv40bNyp//vzasmWL8ubNm2PbdXZpfZ6zZs3S9evX01wmSStXrlRCQkJ2lwYAAHJQVo4JcqNChQpp4MCBkqTExEQdOXJEX375pb788kutXbtWnTp1Uvfu3VPdmb5u3Tr9/PPPCgsLS3Vhz4Mu9Fm+fLl69uwpV1dXtWzZUmXKlJHJZNKJEyf01VdfaefOnQoLC7PjXiI3GTFihPLnz6/k5GRFRUXp888/1+7duxUREaG5c+dmaqy0ZlyIjIzUF198oYYNG6ZazgwNwD+AAeAfJTo62pBkNG/ePNWyN954w5BkNGzY0C7batiwoSHJiI6Otst4D8ue++Yo27dvNyQZYWFhji4lRyxbtsyQZEydOtWmPTk52WjZsqUhyZgwYUK660sySpQokaVtSzLKlSuXpXX/KiQkJMs1wFaJEiUMDl0AAMA/7ZggvePSjz766IHHu2FhYYYkY/v27Zna5p9//mkUKFDA8PLyMg4fPpxq+e3bt41vvvkmU2M+akqUKMFxejZI+TvAhQsXbNp/+eUXw8PDwzCZTEZUVNRDbyflXHHixIkPPZY9pPxbe1T+/gHkdkw/BcBq0KBBkqQff/xRktS1a1eZTCb98MMPafafMGGCTCaTPvroo0xt588//7ROwePu7q6CBQvqueee0549e1L1TbnN9LvvvtPy5cv1+OOPy9PT0+bKixs3big8PFxVq1aVp6envL29VaNGDY0fP1537txJNealS5cUFhYmPz8/eXh4qHbt2hm69VqS3nrrLZlMJq1cuTLN5Z9//rlMJpPeeOMNa9vBgwf14osvKjg4WG5ubipcuLCeeOIJvf322xnaZkZFR0fr1VdftW4nICBA3bt319mzZ1P1TXm+SEbfiwsXLmjIkCEqU6aMPDw85OPjowoVKqhfv366fv26Td/Y2FgNHTpUISEhcnNzU5EiRdShQwcdPnw41bgp845GRUVpxowZqlixotzc3B44lZbZbLb2iYiIyPB79LD++vO4du1aVa9eXR4eHgoICNCQIUN069atVH2jo6N19uzZdKe+2rlzp1q3bi0/Pz+5ubmpTJkyevPNN1PdcfDdd99Zb6X+/vvv9cwzz8jHx8dmmgXDMLR06VLVq1dPXl5e8vT0VM2aNbV06dKH2pe/19u2bVv5+/vLzc1NQUFBateunXbv3m3TLzO12EujNJ6pkTKF2fLly7VhwwbVqlVLnp6eKlasmMaPHy+LxSJJ1jugPDw8FBwcrPfffz/NbThivwAAQMbcvn1bM2fO1OOPP658+fKpQIECeuqpp7R+/fpUfVOOQ6OjozVnzhyVL19ebm5uKlGihMLDw63HCCksFouWLFmiJ598UgULFpSHh4eKFy+u1q1bp3n8vGzZMtWqVUv58+dX/vz5VatWLS1fvjxVv4wc46Xn5ZdfVr58+XT27FnFxsZm+H3KiMOHD+vGjRtq3LixKlWqlGp5njx59PTTT9u0/fW464svvtCTTz4pT09PFS5cWD179tSlS5fS3FZmzmOy0v+LL77QE088IQ8PD/n7+6t37966du1amn3TOp5MkdYzE7K6z+k5e/asevXqZZ3uq3jx4urVq5fOnTtn069p06Yym83p7vPgwYNlMpm0ZcsWm3Z7nntkVpUqVdSwYUMZhqEDBw5o69atMplMGjBgQJr9f/31V5nNZjVv3jzT29qwYYMaN24sb29veXh4qFq1apo5c6bu3r1r0y9lGuPu3bvr2LFjeuGFF1SoUKFUn/MXX3yhZ555RoUKFZK7u7tKliypbt26pXmOaxhGhv5PAfBwCDUApJJyoNK3b19J0pIlS1L1SU5O1rJly1SoUCG1a9cuw2MnJiaqSZMmmjx5svLly6ehQ4eqTZs22r59uxo2bKhPP/00zfXef/99DRgwQOXKldPgwYOt02NdvnxZTz75pCZNmiQXFxf1799fPXv2VNGiRTVt2jT9+eefNuPExcWpfv36OnLkiLp166Z27drpwIEDat68eZoHJH+XEvSsXr06zeWrVq2SJHXr1k3SvVti69atq02bNql+/foaPny4XnzxRXl6emrRokUZft8eZP/+/apRo4ZWrFih0NBQDRkyRE899ZTWrFmjJ598UlFRUanWyeh7kZCQoHr16mnu3LkqVaqUBg0apO7du6ts2bJatWqVrly5Yu175coV1a5dW7Nnz1bJkiU1fPhwNWnSRJ9//rlq1aqV6g/fKQYNGqR33nlHNWvW1NChQ1WlSpUM77ura87PpDhv3jz16dNHlSpVUv/+/eXr66s5c+bo1VdftfZp1KiRJk6cKG9vb3l7e2vixImaOHGizVRYCxYsUKNGjbRnzx4999xzGjx4sIoXL663335bTz/9tG7fvp1q299//731ZKtPnz56+eWXJd07eO7SpYt69eqlK1euqHPnznr11Vf1559/qlevXho5cmSW9yXF7Nmz1ahRI23ZskVPP/20RowYoSZNmujnn3/Wf//7X2u/rNaSnf73v/+pQ4cOeuyxx9SvXz/lz59fU6ZM0YQJE/T+++9r8ODBqlatmvr06SOLxaLRo0enCi8fxf0CAAD3JCUlqXnz5hoxYoQMw1CvXr3UtWtXnT17Vm3atNG8efPSXG/UqFF66623VKdOHfXr10/SvYs/xo8fb9Nv3Lhx6t27t65evarOnTtr6NChatKkiY4cOWLzXAvp3h+Ue/bsqZiYGPXq1Uu9evVSTEyMevTooSFDhqRZR3rHeBll72PiQoUKSZKioqKUnJycqXU/++wzvfTSSypdurT12H7ZsmWqX79+qjAhs+cxme2/cuVKtW3bVidPnlS3bt0UFhamPXv2qFmzZmkea2dVZvY5PSdPntQTTzyhpUuXKjQ0VCNGjFCNGjW0dOlS1axZUydPnrT27datmwzD0Jo1a1KNc/fuXX388ccKDAxU06ZNre32PPd4WCaTSU2bNlWpUqW0du3aNKeQXbJkiQzDUO/evTM19syZM/X888/rl19+UefOnfXaa6/p1q1bGjFihF566aU0n+lx+vRp1a5dW1euXFH37t0VFhZmnTp4xIgRatu2rSIiItS2bVsNGzZM9evX19atW1P925cy/n8KgIfkmBtEADjK/aafmjBhgiHJaNy4sbWtYsWKRoECBYybN2/a9N24caMhyRg6dGi620pr+qnw8HBDktGlSxfDYrFY2w8ePGjkzZvX8PHxMeLj463tEydONCQZ+fLlM3755ZdU22jfvr0hyXj99ddTLbt48aJx584d62tJhiRjwIABRnJysrV9yZIlhiSjb9++6e7LX9WvX99wcXExzp8/b9P+xx9/GHnz5jVq1qxpbRs+fLghyVi3bl2qcWJjYzO0vb9Ka/qp27dvGyVLljQKFChgHDx40Kb/rl27DBcXF6NVq1Y27Zl5L9avX5/uZ33jxg0jMTHR+rpHjx6GJGPcuHE2/b788ktDklG6dGmb7aXcolu8eHHj7Nmzqca/3/RTLVq0MCQZ77//flpvlXU/7Tn9VMrPo7e3t3H8+HFre0JCglG2bFnDbDYbMTExNuukd1v7kSNHDFdXV6NatWqpfhamTp1qSDKmT59ubUv57CUZS5cuTTXeokWLDElGjx49jNu3b1vbk5KSjNatWxuSjAMHDmR5XyIjIw2z2WwEBgamuqXaYrHY9M1sLRn1oKkmUv7P+auUn6E8efIYP/zwg7U9Pj7eKFKkiOHp6WkULVrU+PXXX63Lzp07Z+TNm9eoUqWKzVjZtV8AACBz0jomeP311w1Jxvjx423OM+Lj442aNWsaefPmtTleSTkODQkJsTmuv3LliuHj42MUKFDASEpKsrYXLFjQCAwMNP78889U9fzxxx/W73fs2GFIMipUqGDExcVZ269evWqULVvWkGTs3LnT2v6gYzzDSH/6qbVr1xqSjEqVKqW53l/3M7PTT1ksFiM0NNSQZNSvX99YvHixcejQIePu3bvprpNy3CXJ2Lx5s82ysWPHGpKMgQMHWtsyex6T2f7Xr183vLy8jHz58hknTpywGadBgwZpniukdTyZIq3phTK7z/fTuHFjQ5Lx4Ycf2rT/61//MiQZTZo0sbbFx8cbHh4eRsWKFVONs2HDBkOSMXLkSGubvc897ie96acOHz5snX4q5T2cNm2aIclYvny5Td87d+4YAQEBRpEiRWyOu/8qremnTp8+bbi6uhpFihQxzp07Z21PTEw06tevb0gyVq5caW1P+fuI0pnWOOW9rFKlSqr37c6dO8bFixetrzP7fwqAh0OoAfzDpPzSLlWqlDFx4kRj4sSJxsiRI42nnnrKkGS4u7sb33//vbX/7NmzDUnGkiVLbMZp27atIck4cuRIuttKK9R47LHHjDx58hi//fZbqv69e/dOdZCR8ofXYcOGpep/4cIFw2QyGaVKlUr3QOevUsKRGzdu2LTfuXPHcHV1NR5//PEHjmEYhvHhhx8akowZM2bYtM+fP9+QZMyaNcvalhJqfP311xka+0HSCjU+//xzQ5IxefLkNNdp166dYTabjevXr1vbMvNepIQafw8q/i4pKclwd3c3ChUqlObJ3tNPP53qJC7lwG/27NlpjplyoNq0aVPrz+ugQYOMChUqGJKMunXrpgrc/iq7Qo20DnhTlq1fv96mPb1QY/DgwanejxTJyclG4cKFjdDQUGtbymef3s9p1apVjXz58hkJCQmplv3yyy+GJGPEiBFZ3pf+/ftn+KQms7Vk1MOEGj169EjVv2fPnoYkIzw8PNWyJk2aGC4uLjbBaHbtFwAAyJy/HxMkJycbvr6+RqlSpWwCjRQpx7Nz5861tqUch6Z1bJOy7K8XVRUsWNAoWbKkzQU9aUk5vvjkk09SLVuzZo0hyejZs6e17UHHeIZx77i0UKFC1uPhMWPGGK1atTJMJpORP3/+NI8n/74vmQ01DOPeuWO9evWsf/SVZHh6ehpNmzY1li1blirgSDnuatasWaqxbty4Yfj4+BheXl7Wi5wyex6T2f4rVqwwJBmDBg1K1XfXrl12DTUyus/pOXv2rCHJqFixYqqf4eTkZKN8+fKGJJs/1Hfq1MmQZERERNj079ChgyHJiIyMtLbZ+9zjflLewxEjRhgTJ0403nzzTaNLly6Gh4eHIckYPHiwte/ly5eNvHnzGvXr17cZY926dYYkY9SoUeluJ61QY/LkyYYkY9q0aan679mzJ1U4lPL3kaJFi6YZOKRcSPftt98+cL8z+38KgIeT83N2AHgk/PrrrwoPD5d0bz5Uf39/de7cWWPHjrWZ+ueVV17R2LFjtXjxYvXq1UvSvWdSbNy4UXXr1lXFihUzvM34+HhFRUWpQoUKKl68eKrljRs31uLFixUZGWmdvinFk08+mar/gQMHZBiGGjdurDx58mSohrJlyyp//vw2ba6urvL391dcXFyGxujQoYMGDx6sVatWafjw4db21atXy9XVVZ06dbLpO2vWLL3wwgt6+eWX9fTTT6tBgwYqVqxYhraVEfv27ZMknThxQpMmTUq1/OLFi7JYLDp58qRq1qxpbc/oe9GgQQMFBATo3Xff1c8//6xWrVqpYcOGqlChgs2cqsePH1diYqIaN24sT0/PVHU0btxYW7ZsUWRkpJ566imbZWl9vn+1bds2bdu2zaatXr162rZtm9zc3O67bnYIDQ1N1ZbyM53Rn6OUz+3rr79OtW/SvX+Xx48fT9X+xBNPpGpLSEjQoUOHFBgYqGnTpqVanvJsmbTGy+i+pDxb55lnnklrd+xSS3aqXr16qraAgID7LktOTtalS5dUrFixR3a/AADAvePga9euKTAw0HqO81cp06U+zLFQx44dNX/+fFWuXFkdO3ZU48aNVadOHXl4eNis+9NPP0mSzTMAUzRu3FjSvSlq/y6tY7y/+uOPP1LtW/78+bVlyxbVrl37vutmVcmSJbV7925FRkZq69atOnDggPbs2WM9Nl+5cqU2bdqU6nj878f6KbVWr15d3333naKiolS6dOlMn8dktv/PP/+cbj116tSx65RdGd3n9KT8TDRs2DDVcyvMZrMaNGig48ePKzIyUkFBQZLuTUH10UcfadWqVXr88ccl3Tvn3rBhg6pUqaJq1apZx7DnuUdGzZgxQ9K9qaa8vLxUs2ZN9erVS6+88oq1T+HChdWuXTt9/PHHOn78uMqXLy/p/6bATmtK3Pu537+/OnXqyN3dPc1/f9WqVbNON/VXP/zwg9zc3NSwYcMM12CPc0UAD0aoAfxDNW/eXJs3b35gPx8fH3Xo0EErVqzQ4cOHVblyZS1fvlx3797N9NyW8fHxkiR/f/80l6f8gTGl31+ltU7KA6ozExB4eXml2e7q6prhuWJ9fHzUqlUrffbZZzp69KgqVqyoX3/9Vd9//71atmypIkWKWPvWqlVL3333nd555x2tXbtWy5Ytk3Tv4HDatGnWE5uHcfXqVUlKcz7Vv/r780Uy+l54e3tr3759mjBhgjZs2KCvvvpKkhQUFKSxY8daH+xm78/3r6ZOnaqxY8fKYrHozJkzmjRpklatWqXevXun+9D27JTWe5dyUpTRn6OUzy2zD4xP6726du2aDMNQTExMmifyKf7+MyBlfF+uX78uk8lk/RzT8zC1ZKf77ef9lqWEFY/qfgEAgP87rjpy5IiOHDmSbr+HORaaPXu2QkJCtGzZMk2ZMkVTpkyRu7u7OnTooBkzZsjPz0/SvWNds9mswoULpxrX399fJpMpS8fD5cqVs/7ROS4uTuvWrVP//v31wgsv6MCBA3a9aOrvqlevbnMRyHfffaeuXbtq+/btmj9/voYNG2bTP719SWlPOY/L7HlMZvunbOev52cpXFxcrM8NsYeM7nN6snIu9cwzz8jf318ff/yxpk+fLhcXF/33v//VrVu3Ul0kaM9zj4y6cOGCihYt+sB+ffv21ccff6wlS5Zo+vTpOn/+vDZt2qSGDRuqbNmymdrm/d5Hk8kkf39/xcTEpFqW3n5ev35dxYoVk9mc8UcS2+NcEcCD8aBwAA+U8nCrxYsXS5L+/e9/y8vLSx06dMjUOCm/3C9dupTm8osXL9r0+6u/X60i3QsXJKV5UJLdUg4SUx4MnvLg8L8fPEr3rtrZtGmTrl27pu3bt2v48OE6dOiQnnvuuTQf4J1ZKe/Xhg0bZNybVjDNr8xcXfJ3wcHBWr58ua5cuaKffvpJ06ZNk8Vi0WuvvaaPPvrIpg57fb5pMZvNeuyxx7RixQo1aNBAq1at0rp167KwR46X8j7Ex8ff93P7u7Teq5SxQkND7zvW9u3bs1yvj4+PDMPQhQsXMrRf2VmLI+TW/QIAIDdI+T3dvn37+/6eTrnAKCtcXV01cuRIHTlyRDExMVq7dq2eeuoprVy5Ul26dLGpxWKxWO8O+avLly/LMIyHOh6W7h2Xde/eXfPmzdPFixf12muvZW2nsqhRo0Z66623JEnffvttquXpnQ+ktHt7e0vK/HlMZvunbOfy5cupaklOTtYff/yRqj3lj9d3795Ntex+wURG9zk9WTmXcnFxUadOnXTx4kXrA6tXrVols9mszp07pzm+Pc497K1Ro0YqX768Vq5cqdu3b2vZsmVKTk7O9EWU0v3fR8MwdOnSpUz9+/Px8bHeAQTg0UKoAeCBateurapVq2r16tX65ptvdOrUKXXp0iXNKYbux8vLS4899phOnz6dZhDx3XffSUp7Kpi01KxZU2azWdu3b7deTZ1TWrZsqUKFCmnt2rWyWCxas2aNChQooDZt2qS7joeHhxo1aqQZM2bo9ddf161bt7Rly5aHrqVWrVqSpL179z70WA9iNptVvXp1jR492hpmrF+/XpJUvnx5ubu768cff1RCQkKqdTP7+d6PyWTS7NmzZTKZNG7cOKc8yEz53FJuBX8YBQoUUIUKFXTs2LFsu6U5ZYqwb775xuG1OEJu3S8AAHKDChUqyMvLSwcOHMiR84LAwEB16tRJmzdvVunSpbV161bdunVLklSjRg1J/3fs+1f2PB6WpJ49e+rxxx/XF198oe+//94uY2bU36ex/atdu3alart586YiIyOt54RS5s9jMts/ZfqltOrZu3dvmsGFr6+vpNQXzlksFut0VmnJ6D6nJ+VnYufOnanCBcMwtHPnTpt+KVIuqlu9erV+++037dixQ40bN0515449zz2yQ58+fXTlyhWtW7dOS5cula+vr9q3b5/pce7372///v1KTEzM1L+/J598UklJSdqxY0emawGQvQg1AGRI3759dfXqVfXo0UOSsnTVhCSFhYXpzp07GjdunM3B2i+//KLly5fL29tbbdu2zdBY/v7+at++vc3zQf7q8uXLaR6o2kOePHn08ssv69y5c3rvvfd06tQptW/fPtWcunv37lViYmKq9VOuHHF3d3/oWtq0aaPg4GDNnDnTerD7V3fu3NHu3buzPP6RI0fSvNLl7/uQN29ederUSbGxsZo6dapN382bN+vrr79W6dKlVa9evSzX8lfVq1dX27Ztdfz48Qfegv4oGjBggFxdXTVo0CCdO3cu1fK4uDjrnLAZMXjwYCUkJKh3795pTq0QHR2tM2fOZLnefv36ycXFRW+++abOnj1rs8wwDJ0/fz7HanGU3LpfAAA4O1dXV/Xv319nz57VyJEj0ww2Dh8+nOYV+xmRlJSUZmjw559/6ubNm8qTJ4/1Cv+wsDBJUnh4uM1UQdevX7ees6T0eVgmk0kTJ06UJI0fP94uY6aIjo7WvHnzdOPGjVTLEhISNHv2bElS/fr1Uy3funWrvv76a5u2t99+W3FxcXrllVes71Vmz2Oy0t/Ly0tLly7VyZMnbfq9+eabae53yjMkli9fbtM+c+ZMRUdHp7lOZvY5PcHBwWrcuLGOHDmipUuX2ixbtGiRjh07piZNmlifp5Hi8ccfV8WKFfW///1PH374oQzDSHP2AHufe9hbWFiY3N3dNWzYMEVFRalbt25ZOlfu3LmzXF1dNXPmTJvzk9u3b2vMmDGSpO7du2d4vJS7oIYMGWKdwivF3bt3072zBkD245kaADKka9euGj16tM6fP6/Q0FDrFRCZNXr0aH355ZdatWqVjh07pqZNm+ry5cv65JNPdPfuXS1evFgFChTI8Hjz58/X4cOH9fbbb+urr75SkyZNZBiGTp48qW+++UaXLl2yTlNlb926ddP8+fM1YcIE6+u/mzZtmrZv364GDRooJCRE7u7uOnjwoLZt26bHHntML7zwwkPX4ebmpv/+979q0aKFGjZsqCZNmqhKlSoymUw6e/asdu3apUKFCmX5AcZbtmzRqFGjVK9ePZUtW1aFChVSVFSU1q9fL3d3d5vb3adNm6YdO3ZoypQp+v7771WrVi2dOXNGn376qTw9PbVs2bJMzUf6IBMnTtS6des0efJkderUya4P+8tulStX1vz589W/f3+VK1dOLVu2VKlSpXTjxg1FRUVpx44d6t69uxYuXJih8fr27at9+/ZpxYoV2rNnj5o1a6bAwEBdunRJx48f1/79+7V27VqVLFkyS/VWqVJFs2bN0uDBg1WpUiW1bdtWJUqU0MWLF7Vz504999xzmjVrVo7U4ii5db8AAMgNwsPDdfDgQc2ZM0dffvmlGjRooCJFiigmJkaHDh3Szz//rL1796b5fIUHuXXrlvVYODQ0VMHBwbp586Y2btyoixcvauTIkdaHZTdo0ECDBg3S3LlzVblyZeuUWJ999pl+//13DR48WA0aNLDbfj///PMKDQ3Vt99+qx07djzUlLN/df36dQ0aNEijRo1S/fr1VblyZXl4eCgmJkZffvml/vjjD4WGhmrQoEGp1m3VqpVat26tF198USVLltS+ffu0fft2lSpVSpMnT7b2y+x5TGb7e3t7a86cOerevbueeOIJdezYUd7e3tq4caM8PDzSfFZcjx499N5772nSpEmKjIxUqVKldODAAR0+fFgNGzZM94r9jO7z/SxYsED169dX7969tWHDBlWsWFFHjhzR+vXrVbhwYS1YsCDN9bp166Zx48bpvffek6enZ5p3ONj73MPeChYsqJdeesk6vXNWL6IsVaqUpk2bphEjRqhq1arq0KGD8uXLpw0bNujEiRNq06aNunbtmuHxWrZsqZEjR2r69OkqU6aMXnjhBev/K9u2bdPIkSM1dOjQLNUK4OE4z19/ADiUl5eXXnjhBa1evTrLBxjSvav6v/32W02bNk2ffPKJPvjgA3l6eqphw4Z6/fXX07zS5378/Py0b98+TZ8+XZ9++qnmzZsnd3d3hYSEaOzYscqXL1+Wa32Q2rVrq0yZMjp16pSKFy+uRo0aperTv39/eXt7a//+/dqxY4cMw1BwcLBef/11DRs2LN2HdWfWE088oZ9//lnvv/++vvrqK+3Zs0dubm4qVqyY2rZtq06dOmV57ObNm+vMmTPauXOnPv/8c928eVPFihXTyy+/rNGjR6tixYrWvoULF9b+/fv11ltv6YsvvtCuXbusd99MnDhRlStXtsfuWlWrVk3t2rXTZ599ppUrV6pnz552HT+79e7dW9WrV7debbZhwwZ5e3srODhYw4YNy9RVfCaTScuXL1fLli21ePFibdy4UTdv3lSRIkVUpkwZTZ8+Xc2aNXuoegcOHKjKlStrxowZ2rRpk3X8WrVq2TxjJydqcYTcul8AAOQGbm5u2rRpk/79739r5cqV+uyzz5SUlCR/f39VrFhR/fr1U5UqVbI0dr58+TRt2jRt27ZNu3bt0uXLl+Xr66ty5cpp6tSp6tixo03/OXPmqEaNGlqwYIEWLVokSapUqZImT55svfPdniZNmqTWrVtr/Pjxad7BkBUVKlTQZ599pq+//lr79+/X6tWrde3aNXl5ealSpUpq166d+vfvn+bV9O3bt9err76qt99+W+vWrZOnp6e6d++uqVOnWqd3SpHZ85jM9g8LC5O3t7emTJmiFStWyNvbW88//7zee++9NC/U8/f31/bt2zVixAh98803cnV1VePGjbVv3z5NmTIl3VAjM/ucnnLlyunAgQMKDw/X5s2b9eWXX6pw4cLq0aOHJk6cqBIlSqS5XpcuXfTGG2/ozp07evHFF9OdGsye5x7ZISwsTKtWrVLt2rUf6rxx+PDhKl26tGbOnKnVq1fr9u3bKlu2rGbMmKHBgwdn+jkh77//vurUqaN58+bpv//9rxITExUQEKAmTZro6aefznKdAB6OyUjrSUAAkIYqVaooOjpa58+ft9sf4wEAAAAAzm/58uXq0aOHli1blqkpfpzZP3Gfs8v06dM1atQo/fvf/3a6i9UA5DyeqQEgQzZt2qTDhw+rS5cuBBoAAAAAAMAuEhMTNW/ePPn6+qa68wkA0sL0UwDua8GCBfrtt9+0ZMkSubu7a+zYsY4uCQAAAAAAOLndu3drx44d+vrrr3X27FlNnTpVnp6eji4LgBMg1ABwX9OmTdPvv/+ucuXKaenSpQoJCXF0SQAAAAAAwMlt3bpV4eHh8vPz07BhwzRy5EhHlwTASfBMDQAAAAAAAAAA4BR4pgYAAAAAAAAAAHAKTD+VBovFovPnz6tAgQIymUyOLgcAAABwKMMwdOPGDQUGBsps5rooe+G8AwAAAPg/GT3vINRIw/nz5xUUFOToMgAAAIBHym+//abixYs7uoxcg/MOAAAAILUHnXcQaqShQIECku69eV5eXg6uBgAAAHCs+Ph4BQUFWY+TYR+cdwAAAAD/J6PnHYQaaUi59dvLy4uTCwAAAOD/Y4ok++K8AwAAAEjtQecdTIgLAAAAAAAAAACcAqEGAAAAAAAAAABwCoQaAAAAAAAAAADAKfBMDQAAANiVxWLR7du3HV0GMiFPnjxycXFxdBkAAAAA8ECEGgAAALCb27dvKzo6WhaLxdGlIJN8fHxUtGhRHgYOAAAA4JFGqAEAAAC7MAxDFy5ckIuLi4KCgmQ2M9OpMzAMQwkJCbp8+bIkKSAgwMEVAQAAAED6CDUAAABgF3fv3lVCQoICAwPl6enp6HKQCR4eHpKky5cvq0iRIkxFBQAAgCy5efOm3n//fX3yySc6e/asfH191aZNG73zzjvy9fW977pz587VggUL9Ouvv8rb21utWrXS1KlT5e/vb+2zbds2vfvuu/rll18UFxenQoUKqW7dupo4caKqVKmS3buHRwSXz/2DzZs3TzVr1pSbm5vatm2bZp9Lly6pYMGCql69uk377t27Vbt2bXl7e6tYsWIaN27cfaeZMAxDU6dOVcmSJZUvXz6VLVtW+/fvt+PeAAAAR0tOTpYk5c2b18GVICtSgqg7d+44uBIAAAA4q9atW2vy5Mk6ffq0ypYtq5s3b2rhwoV65plndPfu3XTXGz9+vAYPHqxjx46pRIkSunnzppYtW6ZGjRopISFBknTy5Em1bNlSW7du1Z07d1SpUiXFxsbqs88+U9OmTa3nI8j9CDX+wQIDA/Xmm2+qd+/e6fYZOHCgatSoYdOWnJysNm3aqE2bNrp69ar27Nmjjz/+WIsXL053nDfeeENffvmltm7dqps3b2rLli0KDg62274AAIBHB89kcE58bgAAAHgYR48e1XfffSdJmj17tn7++WdFRERIkg4cOKD//Oc/aa536dIlTZs2TZI0YsQInTx5Uvv27ZPJZNLx48e1cOFCSdIPP/yg27dvS5I2bdqkgwcPaty4cZKkP/74Qzdv3tS5c+fk4+Mjk8mk8PBwSVJMTIy1bcKECdm2/8g5hBr/YO3atVPbtm3l5+eX5vIvvvhCV69eVbdu3Wzar1+/rqtXryosLEwuLi4qWbKkmjVrpkOHDqU5ztWrVzVz5kwtXbpUpUuXlslkUokSJZivGQAAAAAAAMgl/jqLS8rz9f76nL2tW7emuV7KnReS1L59e0lS1apVVbp0aUnS5s2bJUm1atWy3hXesmVLPf7445o6daq8vb01Z84ceXt7Kzg4WP/6178kSe+8846OHDmivn376vr163ryyScJNXIJnqmBNF2/fl3Dhw/X5s2btWfPHptlBQsWVM+ePfXvf/9bY8eO1blz57R161bNnz8/zbH27dsnNzc3ffTRR/rwww+VN29evfzyy3rrrbeYngIAgH+Ac+fOKTY2Nse25+fnxx2hAAAAQA6rUKGCKleurMOHD2vQoEH68MMPFR0dbV0eExOT5nq//fab9fsiRYpYv/f399epU6d07tw5SVKZMmW0detWtW/fXleuXNHVq1clScWLF1fFihWt63Xp0kUbNmzQJ598oqZNm+rSpUvKly+fVq9eLVdX/hyeG/ApIk2jR49W9+7dVaZMmVShhiR16NBBr776qsLDw5WcnKyBAwfq2WefTXOsq1evKj4+XqdOndLJkyd19epVtWrVSvnz59f48eOze1cAAIADnTt3TuXKV1DirYQc26a7h6dOHD+Wa4ON5cuXa+jQoYqLi3N0KQAAAICVi4uLNm3apLFjx2rr1q2KiopSgwYNdPz4cf3666/KkydPpsYzDMPmdUxMjHr27KkrV67ok08+0XPPPac333xTs2bN0nPPPadff/3VOjPMggULtGvXLp0/f16SNH36dJUpU8Y+OwqHI9RAKrt27dKePXt08ODBNJefOHFCbdq00erVq9W2bVtduXJF3bp109ixY63z3/1V/vz5JUnh4eHKnz+/8ufPryFDhujDDz8k1AAAIJeLjY1V4q0EhfSYLveA0tm+vcQLpxW9bKRiY2MzFWp0795dK1askCTlyZNHwcHBeuWVV/T666/f92qu5cuXq0ePHvcdOzo6WiVLlsxwLQAAAICzKl68uFavXm19nZiYqKJFi0qSypUrl+Y6QUFB1u8vX76sUqVKWb+XZD2unz9/vk6fPi0vLy916NBBkvTKK69o1qxZunXrlvbs2aMXX3xR0v9dZJ3i9OnT9tpFPAIINZDKtm3bFBUVpcDAQElSUlKSbt26JT8/Px06dEiHDh1S8eLFrf9JBAQEKCwsTNOmTUsz1KhWrVqO1g8AAB497gGllS+4kqPLuK9nn31Wy5YtU1JSkr766iu99tprypMnj/Xhg2l5+eWXbe5WbdeunSpXrqzJkydb2woXLpzhGm7fvs30nAAAAHBaBw8eVJkyZVSgQAElJydr1KhRun79uqR7x86SVL58eUnSwIEDNXDgQDVt2lSurq66e/euPvvsM9WpU0e//PKLNYhIOd5OGefGjRs6efKkypYtqwMHDli3nS9fPklScnKyunXrpps3b6patWr65Zdf9MEHH6h169Zq2LBhzrwRyFY8KPwf7O7du0pMTNTdu3dlsViUmJio27dva/jw4Tp58qQiIyMVGRmpyZMnq1y5coqMjFSRIkUUGhqq8+fPa926dbJYLLpy5YpWrVqlGjVqpLmdkJAQNWvWTJMnT1ZCQoLOnz+vuXPnqk2bNjm8xwAAAOlzc3NT0aJFVaJECfXv31/NmjXTf/7zH3l5eem///2vTd9169YpX758unv3rooWLWr9yps3rzw9Pa2vb9++rXbt2il//vzWK8ouXbpkHWfSpEmqXr26lixZopCQELm7u0uS4uLi1LdvX/n7+8vd3V2VK1fWxo0bbWr4+uuvVaFCBeXPn1/PPvusLly4kP1vEgAAAHAfS5cuVZEiRVSlShUVLVpU8+bNkyQNHTpUTz75pKR7s8CcOHHC+ty9okWLatSoUZKkGTNmqFy5cqpdu7YMw1CZMmXUt29fSdILL7wgk8kkwzD0+OOPq2rVqurXr58kqUSJEmrUqJEkaerUqdq7d698fX21adMm9e3bVxaLRWFhYTZ3b8B5EWr8g02ZMkUeHh56++23tWHDBnl4eOiZZ56Rl5eXihcvbv3y9fVVnjx5VLx4cbm4uCgkJEQff/yxJk+eLF9fX1WuXFlFihTRBx98YB27UqVKWrNmjfX1mjVrdP36dfn7++uJJ55Q8+bNNXr0aEfsNgAAQIZ4eHjIbDarY8eOWrZsmc2yZcuW6cUXX1SBAgXSXd9isahNmza6evWqduzYoS1btigqKsp6hVqK06dP67PPPtPnn3+uyMhIWSwWtWjRQnv27NHq1at19OhRvfvuu3JxcbGuk5CQoOnTp2vVqlXauXOnzp07p5EjR9r3DQAAAAAy6cknn9Rjjz2mqKgo/fnnnwoNDdWSJUts/m6YlrfffluzZs1S+fLlFR0drXz58iksLEw7d+603oHRtGlTffXVV2rWrJny58+vkydPKjg4WK+++qp27dolDw8PRUREWO+anj17tgICAvT+++8rJCREZ8+e1cCBA7P9PUD2Y/qpf7BJkyZp0qRJD+zXvXt3de/e3abt+eef1/PPP5/uOkeOHLF5XaRIEa1bty4LVQIAAOQswzC0bds2ff311xo0aJBeeukl1a1bVxcuXFBAQIAuX76sr776Slu3br3vONu2bdOhQ4cUHR1tnSd45cqVqlSpkn788Uc98cQTku5NObVy5UrrNFXffPONfvjhBx07dkxly5aVJD322GM2Y9+5c0cLFy60zjc8cOBAmymvAAAAAEd45ZVX9Morr9y3z98fAC5JJpNJQ4YM0ZAhQ+677rPPPmsz/evfhYaG6vbt2zZt+fPnV1RU1H3HhXPhTg0AAABA0saNG5U/f365u7urRYsWevnllzVp0iQ9+eSTqlSpkvVB4qtXr1aJEiXUoEGD+4537NgxBQUF2Tz4sGLFivLx8dGxY8esbSVKlLB57kZkZKSKFy9uDTTS4unpaQ00JFnDFgAAAADI7Qg1AAAAAEmNGzdWZGSkTp06pVu3bmnFihXWW91fffVVLV++XNK9qad69Oghk8lkl+2mbCOFh4fHA9fJkyePzeuUuYUBAAAAILcj1AAAAAB0L1woXbq0goOD5epqO0tr165ddfbsWc2ZM0dHjx5VWFjYA8erUKGCfvvtN/3222/WtqNHjyouLk4VK1ZMd72qVavq999/18mTJ7O+MwAAAACQS/FMDQAAAGS7xAunnXo7vr6+ateunUaNGqVnnnlGxYsXf+A6zZo1U5UqVdSlSxfNmjVLd+/e1YABA9SwYUPVrFkz3fUaNmyoBg0aqH379po5c6ZKly6t48ePy2Qy3Xf+YAAAAAD4JyDUeESdO3dOsbGxji4j1/Dz81NwcLCjywAA4B/Hz89P7h6eil42Mse26e7hKT8/P7uP26tXL61du1Y9e/bMUH+TyaQvvvhCgwYNUoMGDWQ2m/Xss89q7ty5D1z3s88+08iRI9WpUyf9+eefKl26tN59992H3QUAAAA8JP5mh9zOGf6OajKYfDeV+Ph4eXt76/r16/Ly8srx7Z87d07lyldQ4q2EHN92buXu4akTx4898v8gAQBwZomJiYqOjlZISIjc3d2t7Tl94pddB+GrVq3SsGHDdP78eeXNm9fu4ztaep+f5Pjj49yK9xUAAOdy7tw5latQXokJtxxdCpBt3D09dOLYcYf8HTWjx8fcqfEIio2NVeKtBIX0mC73gNKOLsfpJV44rehlIxUbG0uoAQCAAwQHBzv17+CEhARduHBB7777rvr27ZsrAw0AAAA8WGxsrBITbinorWflFlLQ0eUAdpcUfVW/jd/8yP8dlVDjEeYeUFr5gis5ugwAAIB/tPfee09vv/22GjRooHHjxjm6HAAAADiYW0hBeZb3d3QZwD+W2dEFAAAAAI+ySZMm6c6dO9q2bZvy58/v6HIAAAAA4B+NUAMAAAAAAAAAADgFQg0AAAAAAAAAAOAUCDUAAAAAAAAAAIBTINQAAAAAAAAAAABOgVADAAAAAAAAAAA4BVdHFwAAAIDc7dy5c4qNjc2x7fn5+Sk4ODjHtgcAAAAAyDmEGgAAAMg2586dU4Vy5ZSQmJhj2/R0d9exEycINgAAAAAgFyLUAAAAQLaJjY1VQmKi5lUvqzIFPLN9e6duJGhg5EnFxsZmKNQwmUz3XT5x4kRNmjTJTtXZT8mSJXX27FlJkoeHh0qVKqUhQ4bo1VdfVffu3bVixYp01y1RooTOnDmTQ5UCAAAAgH0RagAAACDblSngqare+R1dRioXLlywfv/JJ59owoQJOnHihLUtf/5Hq+bbt28rb968kqTJkyerd+/eSkhI0KeffqrevXurWLFimj17tt59913rOgEBAVq2bJmeffZZSZKLi4tDagcAAAAAe+BB4QAAAPjHKlq0qPXL29tbJpPJpu3jjz9WhQoV5O7urvLly2v+/PnWdc+cOSOTyaTPP/9cjRs3lqenp6pVq6a9e/da+5w9e1atW7eWr6+v8uXLp0qVKumrr76yLt+xY4eefPJJubm5KSAgQGPHjtXdu3etyxs1aqSBAwdq6NCh8vPzU/Pmza3LChQooKJFi+qxxx7TmDFjVLBgQW3ZskXe3t42+yBJPj4+1teFCxfOzrcUAAAAALIVd2oAAAAAaVizZo0mTJigefPmqUaNGvrpp5/Uu3dv5cuXT2FhYdZ+b7zxhqZPn64yZcrojTfeUKdOnXT69Gm5urrqtdde0+3bt7Vz507ly5dPR48etd79ERMTo5YtW6p79+5auXKljh8/rt69e8vd3d1myqsVK1aof//+2rNnT5p1WiwW/e9//9O1a9esd3EAAAAAQG5FqAEAAACkYeLEiZoxY4batWsnSQoJCdHRo0f14Ycf2oQaI0eO1HPPPSdJCg8PV6VKlXT69GmVL19e586dU/v27VWlShVJ0mOPPWZdb/78+QoKCtK8efNkMplUvnx5nT9/XmPGjNGECRNkNt+7qbpMmTJ67733UtU3ZswYvfnmm0pKStLdu3dVsGBBvfrqq9n2fgAAAADAo4DppwAAAIC/+fPPP/Xrr7+qV69eyp8/v/VrypQp+vXXX236Vq1a1fp9QECAJOny5cuSpMGDB2vKlCmqV6+eJk6cqF9++cXa99ixY6pTp47Nw8rr1aunmzdv6vfff7e2hYaGplnjqFGjFBkZqW+//Va1atXSBx98oNKlSz/8zgMAAADAI4xQAwAAAPibmzdvSpIWL16syMhI69fhw4e1b98+m7558uSxfp8SUFgsFknSq6++qqioKHXr1k2HDh1SzZo1NXfu3EzVki9fvjTb/fz8VLp0aT311FP69NNPNXjwYB09ejRTYwMAAACAsyHUAAAAAP7G399fgYGBioqKUunSpW2+QkJCMjVWUFCQ+vXrp88//1wjRozQ4sWLJUkVKlTQ3r17ZRiGte+ePXtUoEABFS9ePNPbePnllzVu3LhMrQcAAAAAzoZnagAAACDbnbqR4HTbCQ8P1+DBg+Xt7a1nn31WSUlJOnDggK5du6bhw4dnaIyhQ4eqRYsWKlu2rK5du6bt27erQoUKkqQBAwZo1qxZGjRokAYOHKgTJ05o4sSJGj58uPV5GpkxZMgQVa5cWQcOHFDNmjUzvT4AAAAAOANCDQAAAGQbPz8/ebq7a2DkyRzbpqe7u/z8/B56nFdffVWenp56//33NWrUKOXLl09VqlTR0KFDMzxGcnKyXnvtNf3+++/y8vLSs88+qw8++ECSVKxYMX311VcaNWqUqlWrpoIFC6pXr1568803s1RvxYoV9cwzz2jChAn66quvsjQGAAAAADzqCDUAAACQbYKDg3XsxAnFxsbm2Db9/PwUHByc6fW6d++u7t2727R17txZnTt3TrN/yZIlbaaOkiQfHx+btgc9P6Nhw4b64Ycf0l3+3Xffpdl+5syZNNs3b96cqu3vNQIAAACAMyPUAAAAQLYKDg7OUsgAAAAAAMDf8aBwAAAAAAAAAADgFAg1AAAAAAAAAACAU3ikQo2dO3eqdevWCgwMlMlk0rp169Lt269fP5lMJs2aNcum/erVq+rSpYu8vLzk4+OjXr166ebNm9lbOAAAAAAAAAAAyHaPVKjx559/qlq1avrXv/51337/+9//tG/fPgUGBqZa1qVLFx05ckRbtmzRxo0btXPnTvXp0ye7SgYAAMDf8GBq52SxWBxdAgAAAAA80CP1oPAWLVqoRYsW9+0TExOjQYMG6euvv9Zzzz1ns+zYsWPavHmzfvzxR9WsWVOSNHfuXLVs2VLTp09PMwQBAACAfeTJk0cmk0lXrlxR4cKFZTKZHF0SMsAwDN2+fVtXrlyR2WxW3rx5HV0SAAAAAKTrkQo1HsRisahbt24aNWqUKlWqlGr53r175ePjYw00JKlZs2Yym83av3+/XnjhhTTHTUpKUlJSkvV1fHy8dXuOuGLNMAyZzWaZJZnElY4PyyzJbDbLMAyuQAQAIBuZTCYVK1ZMMTExio6OdnQ5yCRPT08VL15cUuq7NjiGAgAAAPCocKpQY9q0aXJ1ddXgwYPTXH7x4kUVKVLEps3V1VUFCxbUxYsX0x136tSpCg8PT9V+5coVJSYmPlzRWZCYmKjQ0FAV95Hc3XgeyMNK9JE8Q0OVmJioy5cvO7ocAAByPS8vLyUnJzu6DGSC2WyW2WxWXFxcmstv3LiRswUBAAAAQDqcJtSIiIjQ7NmzdfDgQbtPZTBu3DgNHz7c+jo+Pl5BQUEqXLiwvLy87LqtjIiJiVFERIQSnpY8vfLn+PZzm4Q46VhEhNzd3VOFXgAAAHgwd3d3R5cAAAAAAJKcKNTYtWuXLl++rODgYGtbcnKyRowYoVmzZunMmTMqWrRoqivx7969q6tXr6po0aLpju3m5iY3N7dU7SlXrOU0k8l0b+orSYaYi/phWXRvygSTyeSQzxMAAMDZcQwFAAAA4FHhNKFGt27d1KxZM5u25s2bq1u3burRo4ckqU6dOoqLi1NERIRCQ0MlSd9++60sFotq1aqV4zUDAAAAAAAAAAD7eaRCjZs3b+r06dPW19HR0YqMjFTBggUVHBysQoUK2fTPkyePihYtqnLlykmSKlSooGeffVa9e/fWwoULdefOHQ0cOFAdO3ZUYGBgju4LAAAAAAAAAACwr0fqPvIDBw6oRo0aqlGjhiRp+PDhqlGjhiZMmJDhMdasWaPy5curadOmatmyperXr69FixZlV8kAAAAAAAAAACCHPFJ3ajRq1EiGYWS4/5kzZ1K1FSxYUGvXrrVjVQAAAAAAAAAA4FHwSN2pAQAAAAAAAAAAkB5CDQAAAAAAAAAA4BQINQAAAAAAAAAAgFMg1AAAAAAAAAAAAE6BUAMAAAAAAAAAADgFQg0AAAAAAAAAAOAUCDUAAAAAAAAAAIBTINQAAAAAAAAAAABOgVADAAAAAAAAAAA4BUINAAAAAAAAAADgFAg1AAAAAAAAAACAUyDUAAAAAAAAAAAAToFQAwAAAAAAAAAAOAVCDQAAAAAAAAAA4BQINQAAAAAAAAAAgFMg1AAAAAAAAAAAAE6BUAMAAAAAAAAAADgFQg0AAAAAAAAAAOAUCDUAAAAAAAAAAIBTINQAAAAAgCxITk7W+PHjFRISIg8PD5UqVUpvvfWWDMNwdGkAAABAruXq6AIAAAAAwBlNmzZNCxYs0IoVK1SpUiUdOHBAPXr0kLe3twYPHuzo8gAAAIBciVADAAAAALLg+++/V5s2bfTcc89JkkqWLKmPPvpIP/zwg4MrAwAAAHIvQg0AAAAAyIK6detq0aJFOnnypMqWLauff/5Zu3fv1syZM9Psn5SUpKSkJOvr+Ph4SZLFYpHFYsmRmgEAQNYZhiGz2SyzTDIz2yRyIbNMMpvNMgzDIcenGd0moQYAAAAAZMHYsWMVHx+v8uXLy8XFRcnJyXr77bfVpUuXNPtPnTpV4eHhqdqvXLmixMTE7C4XAAA8pMTERIWGhirApajcEn0dXQ5gd0kuZnmHhioxMVGXL1/O8e3fuHEjQ/0INQAAAAAgC/7zn/9ozZo1Wrt2rSpVqqTIyEgNHTpUgYGBCgsLS9V/3LhxGj58uPV1fHy8goKCVLhwYXl5eeVk6QAAIAtiYmIUERGh0sll5enOXZbIfRKSL+t0RITc3d1VpEiRHN++u7t7hvoRagAAAABAFowaNUpjx45Vx44dJUlVqlTR2bNnNXXq1DRDDTc3N7m5uaVqN5vNMpvN2V4vAAB4OCaT6d60kTJkMTm6GsD+LLo37ZTJZHLI8WlGt8mRMwAAAABkQUJCQqoTLxcXF56PAQAAAGQj7tQAAAAAgCxo3bq13n77bQUHB6tSpUr66aefNHPmTPXs2dPRpQEAAAC5FqEGAAAAAGTB3LlzNX78eA0YMECXL19WYGCg+vbtqwkTJji6NAAAACDXItQAAAAAgCwoUKCAZs2apVmzZjm6FAAAAOAfg2dqAAAAAAAAAAAAp0CoAQAAAAAAAAAAnAKhBgAAAAAAAAAAcAqEGgAAAAAAAAAAwCkQagAAAAAAAAAAAKdAqAEAAAAAAAAAAJwCoQYAAAAAAAAAAHAKhBoAAAAAAAAAAMApEGoAAAAAAAAAAACnQKgBAAAAAAAAAACcAqEGAAAAAAAAAABwCoQaAAAAAAAAAADAKRBqAAAAAAAAAAAAp0CoAQAAAAAAAAAAnAKhBgAAAAAAAAAAcAqEGgAAAAAAAAAAwCkQagAAAAAAAAAAAKdAqAEAAAAAAAAAAJwCoQYAAAAAAAAAAHAKhBoAAAAAAAAAAMApEGoAAAAAAAAAAACnQKgBAAAAAAAAAACcAqEGAAAAAAAAAABwCoQaAAAAAAAAAADAKRBqAAAAAAAAAAAAp0CoAQAAAAAAAAAAnMIjFWrs3LlTrVu3VmBgoEwmk9atW2dddufOHY0ZM0ZVqlRRvnz5FBgYqFdeeUXnz5+3GePq1avq0qWLvLy85OPjo169eunmzZs5vCcAAAAAAAAAAMDeHqlQ488//1S1atX0r3/9K9WyhIQEHTx4UOPHj9fBgwf1+eef68SJE3r++edt+nXp0kVHjhzRli1btHHjRu3cuVN9+vTJqV0AAAAAAAAAAADZxNXRBfxVixYt1KJFizSXeXt7a8uWLTZt8+bN05NPPqlz584pODhYx44d0+bNm/Xjjz+qZs2akqS5c+eqZcuWmj59ugIDA9McOykpSUlJSdbX8fHxkiSLxSKLxWKPXcsUwzBkNptllmSSkePbz23MksxmswzDcMjnCQAA4Ow4hgIAAADwqHikQo3Mun79ukwmk3x8fCRJe/fulY+PjzXQkKRmzZrJbDZr//79euGFF9IcZ+rUqQoPD0/VfuXKFSUmJmZL7feTmJio0NBQFfeR3N2YOuthJfpInqGhSkxM1OXLlx1dDgAAgNO5ceOGo0sAAAAAAElOHGokJiZqzJgx6tSpk7y8vCRJFy9eVJEiRWz6ubq6qmDBgrp48WK6Y40bN07Dhw+3vo6Pj1dQUJAKFy5sHTsnxcTEKCIiQglPS55e+XN8+7lNQpx0LCJC7u7uqX4+AAAA8GDu7u6OLgEAAAAAJDlpqHHnzh116NBBhmFowYIFDz2em5ub3NzcUrWbzWaZzTn/2BGTyXRv6itJhkw5vv3cxqJ7UyaYTCaHfJ4AAADOjmMoAAAAAI8Kpws1UgKNs2fP6ttvv7W5k6Jo0aKpphe6e/eurl69qqJFi+Z0qQAAAAAAAAAAwI6c6pKrlEDj1KlT2rp1qwoVKmSzvE6dOoqLi1NERIS17dtvv5XFYlGtWrVyulwAAAAAAAAAAGBHj9SdGjdv3tTp06etr6OjoxUZGamCBQsqICBAL774og4ePKiNGzcqOTnZ+pyMggULKm/evKpQoYKeffZZ9e7dWwsXLtSdO3c0cOBAdezYUYGBgY7aLQAAAAAAAAAAYAePVKhx4MABNW7c2Po65eHdYWFhmjRpktavXy9Jql69us1627dvV6NGjSRJa9as0cCBA9W0aVOZzWa1b99ec+bMyZH6AQAAAAAAAABA9nmkQo1GjRrJMIx0l99vWYqCBQtq7dq19iwLAAAAAAAAAAA8ApzqmRoAAAAAAAAAAOCfi1ADAAAAAAAAAAA4BUINAAAAAAAAAADgFAg1AAAAAAAAAACAUyDUAAAAAAAAAAAAToFQAwAAAAAAAAAAOAVCDQAAAAAAAAAA4BQINQAAAAAAAAAAgFMg1AAAAAAAAAAAAE6BUAMAAAAAAAAAADgFQg0AAAAAAAAAAOAUCDUAAAAAAAAAAIBTINQAAAAAAAAAAABOgVADAAAAAAAAAAA4BUINAAAAAAAAAADgFAg1AAAAAAAAAACAUyDUAAAAAAAAAAAAToFQAwAAAAAAAAAAOAVCDQAAAAAAAAAA4BQINQAAAAAAAAAAgFMg1AAAAAAAAAAAAE6BUAMAAAAAAAAAADgFQg0AAAAAAAAAAOAUCDUAAAAAAAAAAIBTINQAAAAAAAAAAABOgVADAAAAAAAAAAA4BUINAAAAAAAAAADgFAg1AAAAAAAAAACAUyDUAAAAAAAAAAAAToFQAwAAAAAAAAAAOAVCDQAAAAAAAAAA4BQINQAAAAAAAAAAgFMg1AAAAAAAAAAAAE6BUAMAAAAAAAAAADgFQg0AAAAAAAAAAOAUCDUAAAAAAAAAAIBTINQAAAAAAAAAAABOgVADAAAAAAAAAAA4BUINAAAAAAAAAADgFAg1AAAAAAAAAACAUyDUAAAAAAAAAAAAToFQAwAAAAAAAAAAOAVCDQAAAAAAAAAA4BQINQAAAAAAAAAAgFMg1AAAAAAAAAAAAE6BUAMAAAAAAAAAADgFQg0AAAAAAAAAAOAUCDUAAAAAAAAAAIBTINQAAAAAAAAAAABOgVADAAAAAAAAAAA4BUINAAAAAAAAAADgFAg1AAAAAAAAAACAUyDUAAAAAAAAAAAAToFQAwAAAAAAAAAAOAVCDQAAAAAAAAAA4BQeqVBj586dat26tQIDA2UymbRu3Tqb5YZhaMKECQoICJCHh4eaNWumU6dO2fS5evWqunTpIi8vL/n4+KhXr166efNmDu4FAAAAAAAAAADIDo9UqPHnn3+qWrVq+te//pXm8vfee09z5szRwoULtX//fuXLl0/NmzdXYmKitU+XLl105MgRbdmyRRs3btTOnTvVp0+fnNoFAAAAAAAAAACQTVwdXcBftWjRQi1atEhzmWEYmjVrlt588021adNGkrRy5Ur5+/tr3bp16tixo44dO6bNmzfrxx9/VM2aNSVJc+fOVcuWLTV9+nQFBgbm2L4AAAAAAAAAAAD7eqRCjfuJjo7WxYsX1axZM2ubt7e3atWqpb1796pjx47au3evfHx8rIGGJDVr1kxms1n79+/XCy+8kObYSUlJSkpKsr6Oj4+XJFksFlkslmzao/QZhiGz2SyzJJOMHN9+bmOWZDabZRiGQz5PAAAAZ8cxFAAAAIBHhdOEGhcvXpQk+fv727T7+/tbl128eFFFihSxWe7q6qqCBQta+6Rl6tSpCg8PT9V+5coVm6mtckpiYqJCQ0NV3Edyd+N5IA8r0UfyDA1VYmKiLl++7OhyAAAAnM6NGzccXQIAAAAASHKiUCM7jRs3TsOHD7e+jo+PV1BQkAoXLiwvL68crycmJkYRERFKeFry9Mqf49vPbRLipGMREXJ3d08VegEAAODB3N3dHV0CAAAAAEhyolCjaNGikqRLly4pICDA2n7p0iVVr17d2ufvV+LfvXtXV69eta6fFjc3N7m5uaVqN5vNMptz/lnqJpPp3tRXkgyZcnz7uY1F96ZMMJlMDvk8AQAAnB3HUOmLiYnRmDFjtGnTJiUkJKh06dJatmyZzZS4AAAAAOzHac5OQkJCVLRoUW3bts3aFh8fr/3796tOnTqSpDp16iguLk4RERHWPt9++60sFotq1aqV4zUDAAA8yK+//qoWLVrI19dXxYoV03vvvZeqz6VLl1SwYEHrhRxpSUpKUqNGjVSkSBF5eXmpfPnyWrRoUTZWDuDatWuqV6+e8uTJo02bNuno0aOaMWOGfH19HV0aAAAAkGs9Undq3Lx5U6dPn7a+jo6OVmRkpAoWLKjg4GANHTpUU6ZMUZkyZRQSEqLx48crMDBQbdu2lSRVqFBBzz77rHr37q2FCxfqzp07GjhwoDp27KjAwEAH7RUAAEDakpOT9fzzz6tt27Zav369oqKi9PTTT6t48eLq3Lmztd/AgQNVo0YN/fHHH+mO5erqqrlz56pChQpydXXV0aNH1bhxY1WoUEFPPfVUTuwO8I8zbdo0BQUFadmyZda2kJCQdPsnJSUpKSnJ+jo+Pl7SvbuKeRg7AACPPsMw7s3sIpPMhqOrAezPrHsz3RiG4ZDj04xu85EKNQ4cOKDGjRtbX6c85yIsLEzLly/X6NGj9eeff6pPnz6Ki4tT/fr1tXnzZps5ftesWaOBAweqadOmMpvNat++vebMmZPj+wIAAPAgJ06c0IkTJzRx4kTlyZNH5cqVU69evbRo0SJrqPHFF1/o6tWr6tatm2bNmpXuWC4uLqpSpYr1tclkkslk0unTpwk1gGyyfv16NW/eXC+99JJ27NihYsWKacCAAerdu3ea/adOnarw8PBU7VeuXFFiYmJ2lwsAAB5SYmKiQkNDFeBSVG6J3JmJ3CfJxSzv0FAlJiamesxDTrhx40aG+j1SoUajRo1kGOnHnCaTSZMnT9bkyZPT7VOwYEGtXbs2O8oDAACwq5SrUP56/GOxWPTLL79Ikq5fv67hw4dr8+bN2rNnT4bGbNWqlbZu3aqkpCRVrVpVL7zwgv0LByBJioqK0oIFCzR8+HC9/vrr+vHHHzV48GDlzZtXYWFhqfqPGzfOeuGWdO9OjaCgIBUuXFheXl45WToAAMiCmJgYRUREqHRyWXm6c5clcp+E5Ms6HREhd3d3FSlSJMe3/9ebF+7nkQo1AAAA/knKlSunkiVLasKECZo8ebJOnz6tpUuXWqekGT16tLp3764yZcpkONTYuHGjkpOTtXv3bu3YsUMeHh7ZuQvAP5rFYlHNmjX1zjvvSJJq1Kihw4cPa+HChWmGGm5ubnJzc0vVbjabeRg7AABOwGQy3Zs2UoYsJkdXA9ifRfemnTKZTA45Ps3oNjlyBgAAcJA8efLoiy++0E8//aRixYqpS5cu6tGjhwoVKqRdu3Zpz549GjNmTKbHdXFxUcOGDXXp0iW9//772VA5AEkKCAhQxYoVbdoqVKigc+fOOagiAAAAIPfjTg0AAAAHqlSpkr755hvr6zFjxqhhw4batm2boqKiFBgYKOneA4Zv3bolPz8/HTp0SAEBAQ8c+86dOzp16lS21Q7809WrV08nTpywaTt58qRKlCjhoIoAAACA3I9QAwAAwIF++eUXlSpVSnny5NHGjRu1dOlSbdu2TSVLltSrr75q7ffpp59qyZIl+vrrr9Oc2zQyMlJXrlxR/fr1lSdPHn399ddas2aNFi9enJO7A/yjDBs2THXr1tU777yjDh066IcfftCiRYu0aNEiR5cGAAAA5FqEGgAAAA70n//8RwsWLFBiYqKqVaumdevWqWrVqpJk8+BgX19f5cmTR8WLF7e2VapUSa+//rq6dOmiu3fv6vXXX9eJEydkMplUsmRJzZw5U507d87xfQL+KZ544gn973//07hx4zR58mSFhIRo1qxZ6tKli6NLAwAAAHItQg0AAAAHmjJliqZMmfLAft27d1f37t1t2o4cOWL9vmbNmvrxxx/tXR6AB2jVqpVatWrl6DIAAACAfwweFA4AAAAAAAAAAJwCoQYAAAAAAAAAAHAKhBoAAAAAAAAAAMApEGoAAAAAAAAAAACnQKgBAAAAAAAAAACcgqujCwAAAHgUnDt3TrGxsY4uI9fw8/NTcHCwo8sAAAAAAOQyhBoAAOAf79y5cypXvoISbyU4upRcw93DUyeOHyPYAAAAAADYFaEGAAD4x4uNjVXirQSF9Jgu94DSji7H6SVeOK3oZSMVGxtLqAEAAAAAsCtCDQAAgP/PPaC08gVXcnQZAAAAAAAgHTwoHAAAAAAAAAAAOAVCDQAAAAAAAAAA4BQINQAAAAAAAAAAgFPgmRoAAAAAcrW4uDh9//33Onr0qGJjY2UymeTn56cKFSqoTp068vX1dXSJAAAAADKIUAMAAABArnP79m2tXbtWy5cv1+7du2WxWNLsZzabVa9ePfXo0UOdOnWSm5tbDlcKAAAAIDOYfgoAAABArrJw4UI99thj6tevn7y8vPTBBx9o9+7dOn/+vG7duqWEhATFxMRo9+7dmjlzpry9vdWvXz+VKlVKH374oaPLBwAAAHAf3KkBAAAAIFd55513NHLkSPXo0UPe3t5p9gkICFBAQIDq1q2rwYMHKz4+XkuXLtXUqVPVt2/fHK4YAAAAQEYRagAAAADIVaKiouTqmrlTHS8vLw0dOlQDBw7MpqoAAAAA2APTTwEAAADIVTIbaNhrXQAAAADZj1ADAAAAQK72oOdk3Lp1izs0AAAAACdBqAEAAAAgV+vfv7+effZZxcTEpFq2a9cuValSRYsXL3ZAZQAAAAAyi1ADAAAAQK62evVqHThwQJUrV9aKFSskSYmJiRo6dKgaN24sDw8P7d2718FVAgAAAMiILE0YGxcXp++//15Hjx5VbGysTCaT/Pz8VKFCBdWpU0e+vr72rhMAAAAAsqRz585q3LixevfurZ49e+qTTz7Rr7/+qqioKI0ePVrh4eHKkyePo8sEAAAAkAEZDjVu376ttWvXavny5dq9e7csFkua/cxms+rVq6cePXqoU6dOcnNzs1uxAAAAAJAVAQEB+vzzz9WgQQNt3rxZJpNJ06dP17BhwxxdGgAAAIBMyND0UwsXLtRjjz2mfv36ycvLSx988IF2796t8+fP69atW0pISFBMTIx2796tmTNnytvbW/369VOpUqUe+FA+AAAAAMhukZGRqlmzpiIiIvTaa6+pYsWKGj16tEaPHq3bt287ujwAAAAAGZShOzXeeecdjRw5Uj169JC3t3eafQICAhQQEKC6detq8ODBio+P19KlSzV16lT17dvXrkUDAAAAQEZNmjRJU6dOVYkSJbRjxw7VrVtXt2/f1oQJEzRjxgx99dVXWrFihUJDQx1dKgAAAIAHyNCdGlFRURo6dGi6gUZavLy8NHToUJ0+fTrLxQEAAADAw3rrrbfUp08f/fzzz6pbt64kKW/evHr33Xe1e/du3b17V3Xq1HFwlQAAAAAyIkN3ari6Zul54g+9LgAAAAA8rK1bt6px48ZpLqtVq5Z+/vlnvf766zlcFQAAAICsyFLicOPGDcXFxSkoKMjadv78eS1cuFBJSUlq3769nnzySbsVCQAAAABZlV6gkcLNzU0zZszIoWoAAAAAPIwshRp9+vRRdHS09u3bJ0mKj49X7dq19fvvv8tsNmv27NnavHmzGjVqZM9aAQAAAOCBfvvtN5sLsHJqXQAAAADZL0PP1Pi73bt3q1WrVtbXq1ev1vnz5/X999/r2rVrqlq1qqZMmWK3IgEAAAAgo0qXLq2ePXvqhx9+yPA633//vV555RWVKVMmGysDAAAA8LCydKdGbGysihUrZn29fv161a9fX7Vr15YkvfLKKwoPD7dPhQAAAACQCbt27dKbb76p2rVrq0SJEmrSpIkef/xxhYSEyNfXV4Zh6Nq1a4qOjtaBAwf07bffKiYmRo0bN9bOnTsdXT4AAACA+8hSqOHj46OLFy9Kkm7duqVdu3bpjTfe+L9BXV2VkJBgnwoBAAAAIBOefPJJffPNN4qMjNSyZcv0xRdfaNmyZZIkk8kkSTIMQ5IUFBSktm3bqmfPnqpevbqjSgYAAACQQVkKNerWrav58+erfPny2rx5sxITE9WmTRvr8pMnT9rcyQEAAAAAOa169eqaPXu2Zs+erfPnz+v48eP6448/JEmFChVS+fLlFRgY6OAqAQAAAGRGlkKNadOm6ZlnnlH79u0lSSNGjFClSpUkScnJyfr000/17LPP2q9KAAAAAHgIgYGBBBgAAABALpClUKN06dI6ceKEjh49Km9vb5UsWdK6LCEhQfPmzVO1atXsVSMAAAAAAAAAAEDWQg1JypMnT5rBRYECBWymogIAAAAAAAAAALCHLIcaknTu3DlFRUXp2rVr1gft/VW7du0eZngAAAAAAAAAAACrLIUa586dU8+ePbV9+3ZJSjPQMJlMSk5OfrjqAAAAAAAAAAAA/r8shRphYWHau3evxo4dq1q1asnb29vedQEAAAAAAAAAANjIUqixb98+jRkzRuHh4fauBwAAAACyjWEYunLliiSpcOHCMplMDq4IAAAAQGaYs7JS8eLF5evra+9aAAAAACBbHD16VC+++KK8vLwUEBCggIAAeXl56cUXX9Thw4cdXR4AAACADMrSnRojR47UvHnz1KdPH3l6etq7JgAAAACwm127dqlFixayWCxq06aNypYtK0k6ceKE1q9fr02bNmnz5s166qmnHFwpAAAAgAfJUqjRt29fJScnq0yZMnrxxRdVvHhxubi42PQxmUwaNmyYXYoEAAAAgKwaNmyYihQpoh07digoKMhm2W+//aYGDRpo+PDh+vHHHx1UIQAAAICMylKocfjwYb333nu6cOGC5s6dm2YfQg0AAAAAj4IjR47orbfeShVoSFJQUJD69++vSZMm5XxhAAAAADItS6FGnz59dP36dX344YeqVauWvL297V0XAAAAANhFiRIllJSUlO7y27dvpxl4AAAAAHj0ZCnUiIyMVHh4uHr37m3vegAAAADAriZMmKBhw4bpueeeU/Xq1W2W/fTTT5o7d65mzZrlkNoAAAAAZE6WQo2QkBB71wEAAAAA2WLfvn3y9/dXaGio6tatq9KlS0uSTp06pb1796py5crau3ev9u7da13HZDJp9uzZjioZAAAAQDqyFGqEh4dr5MiR6tixI7dpAwAAAHikzZs3z/r9nj17tGfPHpvlhw4d0qFDh2zaCDUAAACAR1OWQo2dO3fKx8dH5cqVU7NmzRQUFCQXFxebPpwEAAAAAHgUWCwWR5cAAAAAwE6yFGr89UqnjRs3ptmHUAMAAAAAAAAAANiTOSsrWSyWB34lJyfbu1YlJydr/PjxCgkJkYeHh0qVKqW33npLhmFY+xiGoQkTJiggIEAeHh5q1qyZTp06ZfdaAAAAAAAAAABAzspSqOEo06ZN04IFCzRv3jwdO3ZM06ZN03vvvae5c+da+7z33nuaM2eOFi5cqP379ytfvnxq3ry5EhMTHVg5AAAAAEcxm81ycXF54BcAAACAR1+Gpp9KSEiQp6dnljbwMOv+3ffff682bdroueeekySVLFlSH330kX744QdJ9+7SmDVrlt588021adNGkrRy5Ur5+/tr3bp16tixY5rjJiUlKSkpyfo6Pj5e0v/dkZLTDMOQ2WyWWZJJxgP74/7MunciaxgG8ykDANLE71774ndv7uPsn+OECRNkMpls2pKTk3XmzBmtW7dO5cqVU6tWrRxUHQAAAIDMyFCoERQUpCFDhqh3794KCAjI0MAxMTH68MMPNX/+fMXGxj5UkSnq1q2rRYsW6eTJkypbtqx+/vln7d69WzNnzpQkRUdH6+LFi2rWrJl1HW9vb9WqVUt79+5NN9SYOnWqwsPDU7VfuXLFIXd4JCYmKjQ0VMV9JHe3mzm+/dwm0UfyDA1VYmKiLl++7OhyAACPIH732he/e3OfGzduOLqEhzJp0qR0l124cEG1a9dW2bJlc64gAAAAAFmWoVBjwYIFmjRpkiZPnqx69eqpWbNmevzxxxUSEiJfX18ZhqFr164pOjpaBw4c0NatW7Vv3z6VKVNG8+fPt1uxY8eOVXx8vMqXLy8XFxclJyfr7bffVpcuXSRJFy9elCT5+/vbrOfv729dlpZx48Zp+PDh1tfx8fEKCgpS4cKF5eXlZbf6MyomJkYRERFKeFry9Mqf49vPbRLipGMREXJ3d1eRIkUcXQ4A4BHE71774ndv7uPu7u7oErJNQECA+vXrp7feekudOnVydDkAAAAAHiBDoUaHDh304osvav369Vq+fLnefvtt3b59O9Ut3IZhKG/evHrmmWf03//+V88//7zMZvs9tuM///mP1qxZo7Vr16pSpUqKjIzU0KFDFRgYqLCwsCyP6+bmJjc3t1TtZrPZrvVnlMlkujf1lSRDpgf2x/1ZdG/KBJPJ5JDPEwDw6ON3r33xuzf3ye2fY758+RQdHe3oMgAAAABkQIZCDeneiUzbtm3Vtm1bJSUlKSIiQsePH9cff/whSSpUqJDKly+v0NDQNAMCexg1apTGjh1rnUaqSpUqOnv2rKZOnaqwsDAVLVpUknTp0iWbabIuXbqk6tWrZ0tNAAAAAJzX4cOHNWfOHKafAgAAAJxEhkONv3Jzc1PdunVVt25de9dzXwkJCamuEnNxcbE+uDAkJERFixbVtm3brCFGfHy89u/fr/79++dorQAAAAAeDSEhIanuMpekuLg4Xb9+XZ6enlq3bl3OFwYAAAAg07IUajhK69at9fbbbys4OFiVKlXSTz/9pJkzZ6pnz56S7k0dMXToUE2ZMkVlypRRSEiIxo8fr8DAQLVt29axxQMAAABwiIYNG6YKNUwmk3x9fVWqVCl17NhRBQsWdFB1AAAAADLDqUKNuXPnavz48RowYIAuX76swMBA9e3bVxMmTLD2GT16tP7880/16dNHcXFxql+/vjZv3pyrH24IAAAAIH3Lly93dAkAAAAA7MSpQo0CBQpo1qxZmjVrVrp9TCaTJk+erMmTJ+dcYQAAAAAAAAAAINs5VagBAAAAAA+SlQucTCaTxo8fnw3VAAAAALAnQg0AAAAAucqkSZNStaU8U8MwjFTthmEQagAAAABOwuzoAgAAAADAniwWi83Xb7/9pipVqqhTp0764YcfdP36dV2/fl379+9Xx44dVa1aNf3222+OLhsAAABABmQ51Dh37pz69euncuXKqWDBgtq5c6ckKTY2VoMHD9ZPP/1ktyIBAAAAIKtee+01lSlTRqtXr1bNmjVVoEABFShQQE888YTWrFmjUqVK6bXXXnN0mQAAAAAyIEuhxtGjR1WjRg198sknCgkJ0fXr13X37l1Jkp+fn3bv3q158+bZtVAAAAAAyIpvv/1WTZo0SXd506ZNtW3bthysCAAAAEBWZSnUGD16tHx8fHTy5EmtXr061by0zz33nHbt2mWXAgEAAADgYbi7u2vv3r3pLv/+++/l7u6egxUBAAAAyKoshRo7d+5U//79VbhwYesD9/4qODhYMTExD10cAAAAADysLl26aM2aNRo8eLBOnTplfdbGqVOnNGjQIK1du1ZdunRxdJkAAAAAMsA1KytZLBZ5enqmu/zKlStyc3PLclEAAAAAYC/Tpk1TbGys5s2bp3/9618ym+9d22WxWGQYhjp16qRp06Y5uEoAAAAAGZGlUOPxxx/Xl19+qQEDBqRadvfuXX388ceqXbv2QxcHAAAAAA8rb968WrVqlUaNGqUvv/xS586dkySVKFFCLVq0ULVq1RxcIQAAAICMylKoMW7cOLVq1Ur9+/dXx44dJUmXLl3S1q1b9c477+jYsWM8KBwAAADAI6Vq1aqqWrWqo8sAAAAA8BCyFGq0aNFCy5cv15AhQ7Ro0SJJUteuXWUYhry8vLRy5Uo1aNDAroUCAAAAwMPYt2+ftm/frsuXL2vAgAEqU6aMEhISdPz4cZUtW1b58+d3dIkAAAAAHiBLoYYkdevWTe3atdM333yj06dPy2KxqFSpUmrevLkKFChgzxoBAAAAIMtu376tjh076osvvpBhGDKZTGrdurXKlCkjs9msZ555RsOGDdMbb7zh6FIBAAAAPECWQw1Jypcvn1544QV71QIAAAAAdjd+/Hht3LhRCxYsUOPGjVWuXDnrMnd3d7300kv64osvCDUAAAAAJ/BQocadO3cUExOja9euyTCMVMsff/zxhxkeAAAAAB7aRx99pP79+6tPnz76448/Ui2vUKGCPv30UwdUBgAAACCzshRqxMXFaeTIkVqzZo1u376dannKLd3JyckPXSAAAAAAPIzLly+rSpUq6S53cXFRQkJCDlYEAAAAIKuyFGp0795dGzZsUMeOHVWrVi15e3vbuy4AAAAAsIugoCAdP3483eV79uxR6dKlc7AiAAAAAFmVpVDjm2++0eDBg/XBBx/Yux4AAAAAsKvOnTtr5syZat++vcqWLStJMplMkqTFixfrP//5j959911HlggAAAAgg7IUahQqVIgrmQAAAAA4hTfeeEP79u1TgwYNVKFCBZlMJg0bNkxXr17V77//rpYtW2rYsGGOLhMAAABABpizslKfPn308ccfy2Kx2LseAAAAALCrvHnzavPmzVq2bJkee+wxlS9fXklJSapataqWL1+uDRs2yMXFxdFlAgAAAMiALN2pMX78eCUlJalmzZrq1q2bihcvnuZJQLt27R66QAAAAAB4WCaTSV27dlXXrl0dXQoAAACAh5ClUCMmJkbffvutIiMjFRkZmWYfk8mk5OTkh6kNAAAAAOwmKSlJBw8e1OXLl1WvXj35+fk5uiQAAAAAmZSlUKNnz546ePCgxo0bp1q1asnb29vedQEAAACA3cyZM0eTJk1SXFycTCaTtmzZoiZNmig2Nlbly5fXe++9p549ezq6TAAAAAAPkKVQY/fu3RozZozCw8PtXQ8AAAAA2NWyZcs0dOhQdezYUc8884xNeOHn56cmTZro448/JtQAAAAAnECWHhRetGhRFSxY0N61AAAAAIDdzZgxQ23atNHatWvVunXrVMtDQ0N15MgRB1QGAAAAILOyFGqMGDFCS5Ys0c2bN+1dDwAAAADY1enTp9WiRYt0lxcsWFB//PFHDlYEAAAAIKuyNP1UYmKi8uTJo9KlS6tDhw4KCgqSi4uLTR+TyaRhw4bZpUgAAAAAyCofHx/Fxsamu/zo0aMqWrRoDlYEAAAAIKuyFGqMHDnS+v28efPS7EOoAQAAAOBR0LJlSy1atEgDBgxItezIkSNavHgxz9MAAAAAnESWQo3o6Gh71wEAAAAA2WLKlCmqVauWKleurNatW8tkMmnFihVaunSpPvvsMwUEBGjChAmOLhMAAABABmQp1ChRooS96wAAAACAbBEYGKiIiAi9/vrr+uSTT2QYhlatWqUCBQqoU6dOevfdd+Xn5+foMgEAAABkQJZCDQAAAABwJkWKFNGSJUu0ZMkSXblyRRaLRYULF5bZbHZ0aQAAAAAyIUOhRkhIiMxms44fP648efIoJCREJpPpvuuYTCb9+uuvdikSAAAAAOzBMAwZhiGTyfTAcxoAAAAAj54MhRoNGzaUyWSyXsWU8hoAAAAAnMHRo0c1YcIEff3110pISJAkeXp6qnnz5po0aZIqV67s4AoBAAAAZESGQo3ly5dr586dunr1qgoXLqzly5dnc1kAAAAAYB+7du1SixYtZLFY1KZNG5UtW1aSdOLECa1fv16bNm3S5s2b9dRTTzm4UgAAAAAPkuFnajRu3FirVq1S586ds7MeAAAAALCrYcOGqUiRItqxY4eCgoJslv32229q0KCBhg8frh9//NFBFQIAAADIqAw/Fc8wjOysAwAAAACyxZEjRzRgwIBUgYYkBQUFqX///jpy5IgDKgMAAACQWRkONQAAAADAGZUoUUJJSUnpLr99+3aagQcAAACAR0+mQg0eDg4AAADA2UyYMEFz5sxRZGRkqmU//fST5s6dq0mTJuV4XQAAAAAyL8PP1JCkrl27qmvXrhnqazKZdPfu3SwVBQAAAAD2sm/fPvn7+ys0NFR169ZV6dKlJUmnTp3S3r17VblyZe3du1d79+61rmMymTR79uwMb+Pdd9/VuHHjNGTIEM2aNcveuwAAAADg/8tUqNGsWTOVLVs2u2oBAAAAALubN2+e9fs9e/Zoz549NssPHTqkQ4cO2bRlJtT48ccf9eGHH6pq1aoPXywAAACA+8pUqBEWFqbOnTtnVy0AAAAAYHcWiyXbxr5586a6dOmixYsXa8qUKfftm5SUZPNsj/j4eGt92VkjAACwD8MwZDabZZZJZsPR1QD2Z5ZJZrNZhmE45Pg0o9vMVKgBAAAAAPg/r732mp577jk1a9bsgaHG1KlTFR4enqr9ypUrSkxMzK4SAQCAnSQmJio0NFQBLkXllujr6HIAu0tyMcs7NFSJiYm6fPlyjm//xo0bGepHqAEAAADgH+X48eP69NNPdeHCBZUrV049evSQl5dXpsf5+OOPdfDgQf34448Z6j9u3DgNHz7c+jo+Pl5BQUEqXLhwlrYPAAByVkxMjCIiIlQ6uaw83bnLErlPQvJlnY6IkLu7u4oUKZLj23d3d89QP0INAAAAALnOvHnzNGfOHH3//ffy8/Oztm/YsEEvvfSSbt++bW2bO3eu9u3bZ9PvQX777TcNGTJEW7ZsyfDJl5ubm9zc3FK1m81mmc3mDG8bAAA4hslkujdtpAxZTI6uBrA/i+5NO2UymRxyfJrRbWa4MovFwvM0AAAAADiF9evXq1SpUjZBxd27d/Xqq6/KxcVFy5Yt06FDh/Tuu+/q7NmzevvttzM1fkREhC5fvqzHH39crq6ucnV11Y4dOzRnzhy5uroqOTnZ3rsEAAAAQNypAQAAACAXOnr0qHr37m3Ttn37dl25ckWvv/66wsLCJEmVKlXSzz//rK+++koffPBBhsdv2rSpDh06ZNPWo0cPlS9fXmPGjJGLi8vD7wQAAACAVAg1AAAAAOQ6f/zxh4KCgmzatm3bJpPJpBdeeMGmvV69evr8888zNX6BAgVUuXJlm7Z8+fKpUKFCqdoBAAAA2A8TtwIAAADIdfz9/XXx4kWbtl27dsnT01PVqlWzac+bN6/y5s2bk+UBAAAAyCJCDQAAAAC5Ts2aNbVixQrduHFDknTkyBH98MMPat68uVxdbW9YP378uIoXL/7Q2/zuu+80a9ashx4HAAAAQPqYfgoAAABArjNx4kQ98cQTKlOmjCpVqqSIiAiZTCaNGzcuVd///e9/atKkiQOqBAAAAJBZ3KkBAAAAINepUqWKvv32W4WGhur8+fOqXbu2vvrqK4WGhtr0++677+Tp6amXXnrJQZUCAAAAyAzu1AAAAACQK9WtW1dffvnlffs0atRIhw4dyqGKAAAAADws7tQAAAAAAAAAAABOgVADAAAAAAAAAAA4BUINAAAAAAAAAADgFAg1AAAAAAAAAACAU3C6UCMmJkZdu3ZVoUKF5OHhoSpVqujAgQPW5YZhaMKECQoICJCHh4eaNWumU6dOObBiAAAAAAAAAABgD04Valy7dk316tVTnjx5tGnTJh09elQzZsyQr6+vtc97772nOXPmaOHChdq/f7/y5cun5s2bKzEx0YGVAwAAAAAAAACAh+Xq6AIyY9q0aQoKCtKyZcusbSEhIdbvDcPQrFmz9Oabb6pNmzaSpJUrV8rf31/r1q1Tx44dc7xmAAAAAAAAAABgH04Vaqxfv17NmzfXSy+9pB07dqhYsWIaMGCAevfuLUmKjo7WxYsX1axZM+s63t7eqlWrlvbu3ZtuqJGUlKSkpCTr6/j4eEmSxWKRxWLJxj1Km2EYMpvNMksyycjx7ec2Zklms1mGYTjk8wQAPPr43Wtf/O7NffgcAQAAADwqnCrUiIqK0oIFCzR8+HC9/vrr+vHHHzV48GDlzZtXYWFhunjxoiTJ39/fZj1/f3/rsrRMnTpV4eHhqdqvXLnikGmrEhMTFRoaquI+krvbzRzffm6T6CN5hoYqMTFRly9fdnQ5AIBHEL977YvfvbnPjRs3HF0CAAAAAEhyslDDYrGoZs2aeueddyRJNWrU0OHDh7Vw4UKFhYVledxx48Zp+PDh1tfx8fEKCgpS4cKF5eXl9dB1Z1ZMTIwiIiKU8LTk6ZU/x7ef2yTEScciIuTu7q4iRYo4uhwAwCOI3732xe/e3Mfd3d3RJQAAAACAJCcLNQICAlSxYkWbtgoVKuizzz6TJBUtWlSSdOnSJQUEBFj7XLp0SdWrV093XDc3N7m5uaVqN5vNMptz/lnqJpPp3tRXkgyZcnz7uY1F9wIxk8mUo59n9+7dtXbtWuXNm9fatmXLFtWpU8em361bt1SlShXFxsYqLi7uvmMuWbJE77//vn7//XcVLlxYs2fPtj4/BgCQdfzutS9H/e5F9uFzBAAAAPCocKqzk3r16unEiRM2bSdPnlSJEiUk3XtoeNGiRbVt2zbr8vj4eO3fvz/VH5KBnDBgwADdvHnT+pXWz+GECROsP8P3s2jRIs2YMUMff/yxbt68qf3796tKlSrZUTYAAAAAAAAAPJKcKtQYNmyY9u3bp3feeUenT5/W2rVrtWjRIr322muS7l1lOXToUE2ZMkXr16/XoUOH9MorrygwMFBt27Z1bPFAGiIiIrR582aNGTPmvv2Sk5M1YcIEzZ49WzVq1JDJZJK/v78ee+yxHKoUAAAAAAAAABzPqUKNJ554Qv/73//00UcfqXLlynrrrbc0a9YsdenSxdpn9OjRGjRokPr06aMnnnhCN2/e1ObNm5kHGA6xcuVKFSxYUJUqVdKMGTNksVisy+7evavevXvrX//6l80UVWk5ceKELl26pIMHD6pkyZIqXry4evfurfj4+OzeBQAAAAAAAAB4ZDhVqCFJrVq10qFDh5SYmKhjx46pd+/eNstNJpMmT56sixcvKjExUVu3blXZsmUdVC3+yQYPHqwTJ07oypUr+ve//63Zs2dr9uzZ1uXvv/++atSooQYNGjxwrKtXr0qStm7dqgMHDigyMlLR0dEaNmxYttUPAAAAAAAAAI8apws1AGfx+OOPq3DhwnJxcVHt2rU1duxYffLJJ5Kk06dPa+HChXr//fczNFb+/PklSePGjZOfn5/8/Pw0btw4bdiwIdvqBwAAAAAAAIBHjaujCwD+Kczm/8sQd+/erUuXLlnvIrpz545u3LghPz8/ffnll6pVq5bNuuXKlWMKNQAAAAAAAAD/eNypAWST//znP4qPj5dhGDpw4IDeffddtW/fXpLUoUMHnT59WpGRkYqMjNSSJUtUoEABRUZGqkaNGqnG8vDwUNeuXTVt2jRdu3ZNcXFxmjZtmtq0aZPTuwUAAAAAAAAADkOoAWSTefPmKTg4WAUKFFCXLl00YMAAjRgxQpLk6emp4sWLW78KFy4sk8mk4sWLWx8a3qJFC73zzjvW8WbNmqXAwECFhISoXLlyKlGihGbOnOmQfQMAAAAAAAAAR2D6KSCb7Ny5M8N9GzVqpLi4OJu2TZs22bzOly+fli9fbofKAAAAAAAAAMA5cacGAAAAAAAAAABwCoQaAAAAAAAAAADAKRBqAAAAAAAAAAAAp0CoAQAAAAAAAAAAnAKhBgAAAAAAAAAAcAquji4AyCnHjh1zdAm5hp+fn4KDgx1dBgAAAAAAAIB/GEIN5Hp3rl+RWVLXrl0dXUqu4enurmMnThBsAAAAAAAAAMhRhBrI9e7eipdF0rzqZVWmgKejy3F6p24kaGDkScXGxhJqAAAAAAAAAMhRhBr4xyhTwFNVvfM7ugwAAAAAAAAAQBbxoHAAAAAAAAAAAOAUCDUAAAAAAAAAAIBTINQAAAAAAAAAAABOgVADAAAAAAAAAAA4BUINAAAAAAAAAADgFAg1AAAAAAAAAACAUyDUAAAAAAAAAAAAToFQAwAAAAAAAAAAOAVCDQAAAAAAAAAA4BQINQAAAAAAAAAAgFMg1AAAAAAAAAAAAE6BUAMAAAAAAAAAADgFQg0AAAAAAAAAAOAUCDUAAAAAAAAAAIBTINQAAAAAACANM2bMUKNGjRQQECA3NzeVKFFCYWFhioqKSnedM2fOyGQypfs1adIkSdLvv/+ufv36qUqVKvL19VX+/PlVuXJlTZ8+XXfu3MmhPQQAAHA+ro4uAAAAAACAR9HcuXN17tw5lStXTh4eHoqOjtbKlSv1zTff6MSJE/Ly8kq1jpubm2rVqmXTFhcXpxMnTkiSAgICJEmnT5/Whx9+qPz586t06dKKiorSkSNHNGrUKEVFRWn+/PnZv4MAAABOiDs1AAAAAABIQ+/evXXmzBkdO3ZMUVFRGjp0qCTp4sWL2rZtW5rrBAQEaN++fTZfzZo1kyT5+vqqS5cukqSCBQtq8eLFio2N1U8//aQzZ84oJCREkrRmzRpJUnx8vEqWLCmTyaQePXpIkm7evKmQkBCZTCa98sor2bn7AAAAjyRCDQAAAAAA0vDGG28oODjY+vqpp56yfu/m5pahMf744w8tW7ZMktS/f3/lz59fklS1alW9+uqr1nF8fX1VuXJlm7G9vLy0cuVKmc1mLV++XFu2bNGYMWN05swZlSxZUvPmzXv4nQQAAHAyhBoAAAAAADxAcnKyFi1aJEl67LHH1LRp0wytN3/+fCUkJMjNzU2DBg1Kt9+JEyf07bffSrp3h0iKBg0aaNSoUZKk/8fefYdHUb1/H//spm16IZQEEoq00BUEEaUojzRRBBUUpIiA0kEQUKQJYqEpigWRIjZUEFHEggiKFAFDJ0qN0kJoIYQkJDnPH/yyX5dsMEDIsuH9uq69kj3nzJl7Znd25+w9pVOnTnrrrbdktVr1wQcfOL38FQAAQGFHUgMAAAAAgEs4e/asHnjgAX333XcqUaKElixZkqczNdLS0vTmm29KupCQKFGihNN2v//+uxo1aqSzZ8+qbdu2Gjt2rEP9uHHjVLNmTSUkJMgYo6FDh+qOO+64+gUDAABwQyQ1AAAAAADIxZEjR9SoUSMtWbJEFStW1OrVq1WlSpU8TTtv3jwdPXpUFotFTz/9tNM2ixcvVuPGjXX06FH17NlTCxYskKenp0Obs2fPKjEx0f58z549V75AAAAAbo6kBgAAAAAATmzfvl233XabNm7cqDvvvFNr1qxRuXLlHNrcfffdqly5skaMGOFQbozR5MmTJUmtWrVSTExMjv5fe+01tW3bVufOndPLL7+sd955Rx4eHjnaPfnkkzp48KAqV64sHx8fff7555o3b14+LikAAID7IKkBAAAAAIATbdu21YEDByRJZ86cUcuWLXXbbbfptttu03vvvSfpwlkTcXFxOnz4sMO0S5YsUVxcnCTZ74nxb2vWrNHAgQOVlZWlgIAALVy40N73bbfdZu9v/vz5WrBggby9vbVgwQL7pan69eun+Pj4a7bsAAAA1yvP/24CAAAAAMCNJy0tzf5/bGysQ13z5s0vOe2kSZMkSXXr1lXDhg0v2feZM2e0bt26HPXx8fHq27evJGnkyJGqXr26qlSpoi+//FJr165V586d9dNPP8lq5XhFAABw4yCpAQAAAACAE/v377/iNqtWrbrkdI0bN5Yx5j/7P3XqlMNzDw8PrVmz5j+nAwAAKKw4nAMAAAAAAAAAALgFkhoAAAAAAAAAAMAtkNQAAAAAAAAAAABugaQGAAAAAAAAAABwC9woHAAAAABuUPHx8UpMTHR1GMA1Ex4erujoaFeHAQAA8hFJDQAAAAC4AcXHx6tSTGWlppxzdSjANWPz81Xczl0kNgAAKERIagAAAADADSgxMVGpKecU9UJz+ZQNc3U4QL5L23dCfz+/TImJiSQ1AAAoREhqAAAAAMANzKdsmPwqF3d1GAAAAECecKNwAAAAAAAAAADgFkhqAAAAAAAAAAAAt0BSAwAAAAAAAAAAuAWSGgAAAAAAAAAAwC2Q1ACAQqJfv36KiopSUFCQSpYsqYEDByo9PV2StGPHDt19990KDQ1ViRIl1LNnT6WkpOTaV1JSkh599FEFBQWpePHieuGFFwpqMQAAAAAAAIBckdQAgEKid+/e2rVrl5KSkrR582Zt3rxZr7zyiiTp0UcfVaVKlXT06FFt3bpVmzdvvmSiol+/fjpx4oTi4+P1yy+/aObMmZo3b15BLQoAAAAAAADgFEkNACgkYmJi5O/vL0kyxshqteqvv/6SJO3du1edOnWSt7e3ihYtqvvuu09bt2512k9KSoo++eQTjR8/XiEhIapYsaL69eunWbNmFdiyAAAAAAAAAM6Q1ACAQuSll15SQECAihUrps2bN6tfv36SpCFDhmjevHk6d+6cjhw5okWLFql169ZO+4iLi1N6erpq1aplL6tVq5a2bNlSEIsAAAAAAAAA5IqkBgAUIsOHD1dycrJ27NihJ598UiVKlJAktWjRQr/++qsCAwMVERGhqKgoPf744077SE5Olr+/vzw9Pe1lISEhOnPmTIEsAwAAAAAAAJAbt05qvPTSS7JYLBo4cKC9LDU1VX369FGRIkUUEBCgdu3a6ejRo64LEgBcICYmRjVr1lTXrl118uRJNW3aVD169FBKSopOnDghf39/derUyem0AQEBSklJUUZGhr3s9OnTCgwMLKjwAQAAAAAAAKfcNqnx+++/65133lGNGjUcygcNGqQlS5bos88+08qVK3Xo0CG1bdvWRVECgOucP39ef/31l/bs2aNz586pf//+8vb2VmhoqHr16qVvvvnG6XSVKlWSl5eXNm/ebC+LjY1V9erVCyp0AAAAAAAAwCnP/25y/UlOTlbHjh01c+ZMjR8/3l5++vRpzZo1Sx999JHuuusuSdLs2bMVExOjtWvX6rbbbnPaX1pamtLS0uzPk5KSJElZWVnKysq6hkviXPYNfq2SLDIFPv/CxmqRrFarjMUqY7G4Ohy3ZyzWC+vTGJdsH3AuOTlZn332mR544AEFBwdr27ZtGj9+vO655x5VrFhRAQEBevPNN9WzZ0+dO3dO7777rm6++Wanr6HNZtPDDz+skSNH6qOPPlJCQoKmT5+usWPH3lCvef/+/bV48WL7WSoPPvigXn75ZXl7e+uuu+7SmjVr5OXlZW+/a9cuRUZGOu1rx44dGjBggDZt2iQfHx+1bt1aU6dOlZ+fX0EtDv4D3735yyrxXVHI8DoCAAAAuF64ZVKjT58+atWqlZo2beqQ1Ni4caPOnz+vpk2b2ssqV66s6OhorVmzJtekxsSJEzV27Ngc5ceOHVNqamr+L8B/SE1NVe3atVUqRLL5JBf4/AubYsX8VKR2bWWVLatT/jZXh+P2ssJSVfuch1JTU5WQkODqcPB/UlJSNG/ePA0dOlRpaWkKDw9Xq1atNGTIEKWkpGjOnDkaP368nnvuOXl4eOjWW2/VpEmT7K/ho48+qnr16mnAgAGSpFGjRumZZ55RVFSUbDabHn/8cTVv3vyGes0ffvhhDR48WH5+fjp+/Lh69uyp0aNHa9CgQUpPT9dzzz2nnj17OkyT2/rp0KGD6tSpo9mzZyspKUmdO3fWiBEj9NxzzxXEoiAP+O7NX6khkl/t2nxXFCLcVwkAAADA9cLtkhqffPKJNm3apN9//z1H3ZEjR+Tt7a2QkBCH8uLFi+vIkSO59jlixAgNHjzY/jwpKUlRUVEqWrSogoKC8i32vDp48KA2btyolP8n+QUFFPj8C5vjCSnav3GjrL6ZCgn2d3U4bs96+qw2boyVzWZTsWLFXB0O/mXFihW51t1777269957c63/8ccfHZ4XK1ZMX3zxRb7F5o7+/f62WCyy2Ww6fPiwihUrJm9vbwUGBuZ5G4iPj9fbb7+tUqVKSZLatm2rNWvWsA1dR/juzV8pp6SdGzfyXVGI2GwcGAIAAADg+uBWSY2///5bAwYM0A8//JCvAysfHx/5+PjkKLdaL1xmp6BZLJYLl76SZMTlkq5WlrlwyQSLyZLFcEmRq2UxFy7LZrFYXLJ9AAXppZde0vjx43X27FkVKVJEL7/8sv19P2HCBL3wwgsqXbq0Bg0apM6dO+faz5AhQzR//nzVrl1bp0+f1pdffqkePXqwDV1H+O7NX1kS3xWFDK8jAAAAgOuFW41ONm7cqISEBN1yyy3y9PSUp6enVq5cqddff12enp4qXry40tPTderUKYfpjh49qhIlSrgmaACA2xo+fLiSk5O1Y8cOPfnkk/bvkokTJ2rPnj06evSoXnrpJfXr10+LFi3KtZ8WLVro119/VWBgoCIiIhQVFaXHH3+8oBYDAAAAAACg0HCrpMbdd9+trVu3KjY21v6oU6eOOnbsaP/fy8tLy5cvt08TFxen+Ph41a9f34WRAwDcWUxMjGrWrKmuXbtKkurXr6/g4GB5eXmpWbNm6tWrlz799FOn0548eVJNmzZVjx49lJKSohMnTsjf31+dOnUqwCUAAAAAAAAoHNzq8lOBgYGqVq2aQ5m/v7+KFCliL+/evbsGDx6ssLAwBQUFqV+/fqpfv36uNwkHACAvzp8/r7/++stp3aUuy7Jnzx6dO3dO/fv3l8Vikbe3t3r16qUWLVpcq1ABAAAAAAAKLbdKauTF1KlTZbVa1a5dO6WlpalZs2aaMWOGq8MCcAOJj49XYmKiq8MoNMLDwxUdHV2g80xOTtZnn32mBx54QMHBwdq2bZvGjx+vZs2a6dSpU/rtt9/UuHFj+fj46Oeff9bbb7+tmTNnOu2rcuXKCggI0IwZM9SrVy+dO3dOM2fO1M0331ygywQAAAAAAFAYuH1S4+eff3Z4brPZ9Oabb+rNN990TUAAbmjx8fGqVDlGqedSXB1KoWHz9VPcrp0FmtiwWCz66KOPNGTIEKWlpalYsWJq166dxo4dq7Nnz2rs2LHq0KGDJKlMmTKaMmWKHnroIfv0LVq00J133qlnn31WAQEBWrJkiYYNG6bnnntOHh4eatCggebOnVtgywMAAAAAAFBYuH1SAwCuJ4mJiUo9l6Ky3SbJFlHe1eG4vdTDu7Vv9hAlJiYWaFLD399fP/zwg9M6Pz8/rVu37pLTf/vttw7PGzRooF9//TXf4gMAAAAAALhRkdQAgGvAFlFe/tFVXR0GAAAAAAAAUKjkfmdTAAAAAAAAAACA6whJDQAAAAAAAAAA4BZIagAAAAAAAAAAALfAPTUAANe9nTt3ujqEQiE8PLxAb7gOAAAAAACQ30hqAACuW+dPH5NVUqdOnVwdSqHgZ7NpZ1wciQ0AAAAAAOC2SGoAAK5bGeeSlCXpjVoVVSHQz9XhuLW/zqSob+yfSkxMJKkBAAAAAADcFkkNAMB1r0Kgn2oEB7g6DAAAAAAAALgYNwoHAAAAAAAAAABugaQGAAAAAAAAAABwCyQ1AAAAAAAAAACAWyCpAQAAAAAAAAAA3AJJDQAAAAC4AhMnTtStt96qwMBAFStWTG3atFFcXJyrwwIAAAAKNZIaAAAAAHAFVq5cqT59+mjt2rX64YcfdP78ed1zzz06e/asq0MDAAAACi1PVwcAAAAAAO5o2bJlDs/nzJmjYsWKaePGjWrYsGGO9mlpaUpLS7M/T0pKkiRlZWUpKyvr2gbrhDFGVqtVVllkNQU+e+Cas8oiq9UqY4xLtjEAhQ/fnSjsXP3dmdd5ktQAAAAAgHxw+vRpSVJYWJjT+okTJ2rs2LE5yo8dO6bU1NRrGpszqampql27tiI8SsgnNbTA5w9ca2keVgXXrq3U1FQlJCS4OhwAhQDfnSjsXP3deebMmTy1I6kBAAAAAFcpKytLAwcOVIMGDVStWjWnbUaMGKHBgwfbnyclJSkqKkpFixZVUFBQQYVqd/DgQW3cuFHlMyvKz8ZR7Ch8UjITtHvjRtlsNhUrVszV4QAoBPjuRGHn6u9Om82Wp3YkNQAAAADgKvXp00fbtm3Tr7/+mmsbHx8f+fj45Ci3Wq2yWgv+docWi+XCpa9klGUp8NkD11yWLlw6w2KxuGQbA1D48N2Jws7V3515nSdJDQAAAAC4Cn379tXXX3+tVatWqVSpUq4OBwAAACjUSGoAAAAAwBUwxqhfv35atGiRfv75Z5UtW9bVIQEAAACFHkkNAAAAALgCffr00UcffaTFixcrMDBQR44ckSQFBwfL19fXxdEBAAAAhRMXlQQAAACAK/DWW2/p9OnTaty4sSIiIuyPTz/91NWhAQAAAIUWZ2oAAAAAwBUwxrg6BAAAAOCGw5kaAAAAAAAAAADALZDUAAAAAAAAAAAAboGkBgAAAAAAAAAAcAskNQAAAAAAAAAAgFsgqQEAAAAAAAAAANwCSQ0AAAAAAAAAAOAWSGoAAAAAAAAAAAC3QFIDAAAAAAAAAAC4BZIaAAAAAAAAAADALZDUAAAAAAAAAAAAboGkBgAAAAAAAAAAcAskNQAAAAAAAAAAgFsgqQEAAAAAAAAAANwCSQ0AAAAAAAAAAOAWSGoAAAAAAAAAAAC3QFIDAAAAAAAAAAC4BZIaAAAAAAAAAADALZDUAAAAAAAAAAAAboGkBgAAAAAAAAAAcAskNQAAAAAAAAAAgFsgqQEAAAAAAAAAANwCSQ0AAAAAAAAAAOAWSGoAAAAAAAAAAAC3QFIDAAAAAAAAAAC4BZIaAAAAAAAAAADALZDUAAAAAAAAAAAAboGkBgAAAAAAAAAAcAskNQAAAAAAAOBWVq1apZYtW6po0aKyWCyyWCx6++238zTtJ598oltuuUW+vr4KCwvTgw8+qD179jidR/PmzRUaGiqbzaYyZcpowIAB+b0oAIDLRFIDAAAAAAAAbmXTpk364YcfFBYWdlnTzZo1S4888oj++OMPRUREKDMzU1988YVuv/12HTlyxN5uwYIFuuuuu/Tdd9/Jw8NDVapUkcVi0dKlS/N7UQAAl4mkBgAAAAAAANzKY489pqSkJH333Xd5niY9PV3Dhw+XJLVr10579+7Vzp07FRgYqISEBL344ouSpLNnz+qpp55SZmamnnnmGR05ckSbNm3Svn37tGnTJklSfHy8QkJCZLFYNHbsWEnSwYMH7WWjRo3K5yUGAGQjqQEAAAAAAAC3UqRIEfn6+l7WNL///rsSExMlXUhqSFJkZKRuu+02SdKyZcskST/++KNOnDghSTp69KhKlSqlIkWK6L777tPRo0clSdHR0XrzzTclSS+++KK2b9+uXr166fTp06pbty5JDQC4htwqqTFx4kTdeuutCgwMVLFixdSmTRvFxcU5tElNTVWfPn1UpEgRBQQEqF27dvYvHAAAAAAAANyY/v77b/v/xYoVs/9fvHhxSRfOvpDk8FvTvHnzFB4ernPnzmnJkiVq3LixTp8+LUnq2LGj2rdvr/T0dN1999365ptv5O/vr/nz58vT07MgFgkAbkhuldRYuXKl+vTpo7Vr1+qHH37Q+fPndc899+js2bP2NoMGDdKSJUv02WefaeXKlTp06JDatm3rwqgBAAAAAABwvTLGODzPyMiw/z9u3Dht27bNfpmrgwcPatGiRfb6t956S5GRkfYDaidNmqQKFSoUQNQAcONyq7Rx9mmA2ebMmaNixYpp48aNatiwoU6fPq1Zs2bpo48+0l133SVJmj17tmJiYrR27Vr76YQAAAAAAAC4sURFRdn/T0hIyPF/dHS0JKlkyZL2ultvvVWSVLduXXvZ/v377f+fOHFCSUlJ9ue7d+/O36ABADm4VVLjYtmn+4WFhUmSNm7cqPPnz6tp06b2NpUrV1Z0dLTWrFmTa1IjLS1NaWlp9ufZX0ZZWVnKysq6VuHnyhgjq9UqqySLzH+2x6VZLZLVapWxWGUsFleH4/aMxXphfRrjku3jesf2m7/YfvMP2+6lse3mL6vE+62Q4XUEALiju+++WwcPHtQDDzxgv6R5kSJFdPz4cX3xxRd65JFHdOjQIa1du1aS1Lx5c0nSXXfdJavVqqysLG3YsEHNmjXThg0b7P1mn4mRmZmpxx57TMnJyapZs6a2bNmiqVOnqnXr1mrUqFHBLzAA3CDcNqmRlZWlgQMHqkGDBqpWrZok6ciRI/L29lZISIhD2+LFi+vIkSO59jVx4kSNHTs2R/mxY8eUmpqar3HnRWpqqmrXrq1SIZLNJ7nA51/YFCvmpyK1ayurbFmd8re5Ohy3lxWWqtrnPJSamupwZAsuYPvNX2y/+Ydt99LYdvNXaojkV7s277dC5MyZM64OAQAABwsXLtQzzzzjcKmoUaNGadKkSapXr54+/PBD7dmzRwcOHNDhw4clSd7e3nrxxRfVq1cvffHFFypXrpyOHz+uM2fOKDw8XMOHD5d04YyOvn376vXXX9fzzz+vTz75RHv37pUkValSRQ8++KCkC78nrVmzRqGhofr22281btw4vf322+rSpYu2bNmioKCgAl4rAHBjcNukRp8+fbRt2zb9+uuvV93XiBEjNHjwYPvzpKQkRUVFqWjRoi75Ajp48KA2btyolP8n+QUFFPj8C5vjCSnav3GjrL6ZCgn2d3U4bs96+qw2boyVzWZzuLEaLmD7zV9sv/mHbffS2HbzV8opaefGjbzfChGbjcQyAOD6kpSUpD179jiUHTt2TMeOHVOpUqVyna5nz57y9/fXpEmTtHPnTtlsNrVt21YvvfSSIiMj7e2mTp2qyMhIvffee/rzzz9VsmRJtWrVSuPGjZOPj482btyocePGSZJee+01RURE6NVXX9V3332nffv2qW/fvpo3b961WXgAuMG5ZVKjb9+++vrrr7Vq1SqHL6oSJUooPT1dp06dcjhb4+jRoypRokSu/fn4+MjHxydHudV64VIdBc1isVy49JUkIy63crWyzIUzeywmSxbDJUWulsVcuCybxWJxyfZxvWP7zV9sv/mHbffS2HbzV5bE+62Q4XUEAFxvunbtqq5du16yzb/vffFvHTt2VMeOHS85rdVq1bBhwzRs2DCn9bVr11Z6erpDWUBAgP2MDgDAteNWoxNjjPr27atFixbpp59+UtmyZR3qa9euLS8vLy1fvtxeFhcXp/j4eNWvX7+gwwUAAAAAAAAAAPnIrc7U6NOnjz766CMtXrxYgYGB9vtkBAcHy9fXV8HBwerevbsGDx6ssLAwBQUFqV+/fqpfv36uNwkHAAAAAAAAAADuwa2SGm+99ZYkqXHjxg7ls2fPtp9yOHXqVFmtVrVr105paWlq1qyZZsyYUcCRAgAAAAAAAACA/OZWSQ2Th+up22w2vfnmm3rzzTcLICIAAAAAAAAAAFBQ3CqpAQAAAAAAcCOIj49XYmKiq8MArpnw8HBFR0e7OgwAboikBgAAAAAAwHUkPj5elWIqKzXlnKtDAa4Zm5+v4nbuIrEB4LKR1AAAAAAAALiOJCYmKjXlnKJeaC6fsmGuDgfId2n7Tujv55cpMTGRpAaAy0ZSAwAAAAAA4DrkUzZMfpWLuzoMAACuKyQ1AAAAAMCFYmNjFRAQYH8eGhqqsmXLKjU1VTt27MjR/pZbbpEkxcXF6ezZsw51ZcqUUVhYmI4dO6a///7boS4wMFAVKlRQZmamNm/erJ07d0qSUvedkCT5lg+XxdNDaf+cUmZymsO0XkUD5FXEXxlJqUo/dNqhzurjKVvZIpKkc7sSZGQc6m1lishq81T64SRlnHa8lI5XmL+8igUo82y60v4+6VBn8fSQb/nwC/3uTpTJyHSo94kKlYe/t84nJOv8Ccf14BnsK++IIGWlZih1/3HHfmWRb+Vi/7fsx5WVluFQ7x0ZLM8gm84fP6vzx5Id6jwCfORTKkQmI1Pndue814FvhaKyeFiVFn9SmSnpjv0WD5RnqJ8yTqcq/fBF69DmJVuZC0fjp+w6mqNfW9kisvp4Kv3gaWWcSXWo8wr3l1d4gDKT05T2zynHfr08ZLvp/9bhX8dkMrMc6n2iQ+Xh5630o2eUcTLFoc4zxFfeJYKUlXpeqftPONRZLBb5Vvq/dbj3uLLSHdehT8lgeQTadD7xrM4nOl+HWeczlbrHyTqsWEwWq0VpB04q89xF67BEkDxDfJVx6pzSjyQ59uvrLZ/SoTJZRuf+TLgQ2/+9t3fu3Klq1arJ29tbe/fu1alTjuspMjJSJUqU0KlTp7R3716HOpvNpipVqki6sK1mZTmuw8qVK8vPz8/p/S+KFSumUqVKKTk5WX/++adDnaenp2rUqCFJ2r59u9LSHLe55OQL6y3j5Lkc7wnPQJu8SwYrKy1Dqfsc39+S7EmQ1P0nlJV63qHOOyJYnsE2ZZxMUfrRMw51Hn7e8okOlcnM0rm/juXol8+IC/iMuOBqPyOyZX8XZQsJCVG5cuWUnp6ubdu25VjWWrVqyWq16s8//7RvJ9mio6MVHh6uxMRExcfHO9QFBASoYsWKysrKUmxsbI5+8/oZcfF3p9XbU7Zy//f+jkuQMRe/v8NktXkp/UiSMk45vr89Q/3kXTxQmSnpSou/6P3tYZVvhaIX5rUnUVnnL3p/lwqRR4CPzicm63ziRe9vPiMk8Rnxb5fzGfHv704fHx9VrVpVkrRlyxZlZDgua8WKFRUQEKB//vlHCQkJDnXZ98xJSUnRrl27HOO1WlWrVi1J0o4dO5Sa+r+YLt6uc0NSAwAAAABcqFGjRg7PO3bsqPnz5+uff/5R7dq1c7TP/sGka9euWrt2rUPdBx98oE6dOmnBggXq27evQ90999yj7777TmfPnnXo95/nl0mSqvzQS56hfjo0eaXO/OL4w27EwIYq2qm2ktfHK374Nw51tkrFVPHDjpKk3d0+kbnoh5eKnz4m203hOvreOp1c7PgDVdGutyqi7x06t/Oo9j75uUOdV7EAxSztIUna33+Rzic4DnLLvf2gAupEKXFBrI7N+d2hLvT+aop6/v8p/eAp7e70kUOdxctD1df0lyTFj1ym1DjHQXj0S60U0rSiTn27S4enrXKoC7yznMpOvV+ZZ9Jy9CtJVX/uLY8AHx18ZYWS1x5wqIt8ponCH66lM6v36e9Ryxzq/KpHqPzsDpLktN9Ki7rJJypER97+Tae+dfxhoFiP21SiV32lbD2sff0WOdR5lwpW5S8flyTtfeoLZV70g9pN77eXf41IJX64SYkfbXKoK/JQTZUcdpdS95/IEZPV31vVVvaRJB0Y/rXS9jr+oFl68n0KbnSTTi7ZriNvrnaoC767gkq/fK8yTqQ4XdZqv/WTxdtT/0z4UWc3/eNQV3JkUxVpU12nf96tg+N/dKjzv6WUbnr3IZmMzBz9durUSY0aNVKpUqU0bNgwff6543vtxRdf1IgRI7Rq1Srdf//9DnVVqlTR9u3bJUkNGzbUmTOOP/Jt3LhRt9xyi15++WXNmDHDoW7QoEGaMmWKtm7dqttvv92hLjw8XMeOXfhR8P7779eePXsc6qdPny5JOv3TXzq5yHG7CWlRWdEvtND5hGSn67DGhkGSpH/Gfq+UrYcd6qLGNVdoyxid+uFPHXplhUNdwG2lVe6Ntso6d95pv3xGXMBnxAVX+xnhVfxCMr9Tp04OdQ8++KA+++wzJSQkOP0OTE1NlY+Pj3r27KmVK1c61M2cOVNPPPGEvvzyS/Xo0cOhrlGjRvr55591/vx5p/3+/fffefqMyI43+7vTp1yYKi3oIkna0/MzZZ11/CG6/PxH5Ve5uI7N3aDjn212qAt/9BZFDm6k1N2J2vP4pw51HiG+qvrjk5Kk/U9/pfR/HH/ELjv9AQXWL6PjX2xVwkzHfQE+Iy7gM+J/ruQzolOnTrrpppu0e/duSdLdd9+dI3n/22+/qX79+poyZYqmTp3qUNe7d2+9+eab2rVrV45tLjAwUElJFw5OeOihh5wexPNfLObiFCKUlJSk4OBgnT59WkFBQQU+/02bNql27dqKefZL+UdXLfD5FzaJ67/S/vef1nd31lKN4ID/ngCXtOV0spr9EmvfeYcjtt/8xfabf9h2L41tN3+djd+unS+24f1WiLh6/7iwyl6vK1eudNmZGp06dVKpF5rLVjaMIyz/j7sfYenQL2dq6J/nl2n+/Pl66KGH3O5MjUaNGqnM9AfkGerrOC1HYUviM+Lf3PEzIu3gae3u9JHmz5+vmJgYe931fqbGN9984/DdyZka/8NnxAXu/hnx7+/OWrVqueRMjUaNGv3nuIOkhhOuHrTxw0r+4kfR/MUPo5fG9pu/2H7zD9vupbHt5i+SGoWPq/ePCytXr9fsz77so0iBwiZl11Ht7vSRW34fsX2isHPX7ZNtE4Wdq7fNvO4fWwswJgAAAAAAAAAAgCtGUgMAAACFxhtvvKE6derIx8dHbdq0cahLSkrSo48+qqCgIBUvXlwvvPBCnvo8evSowsLC7KdIAwAAAABchxuFAwAAoNCIjIzUyJEj9eOPP+qffxxvMNuvXz+dOHFC8fHxSkhIUNOmTVW6dGl17tz5kn327dtXN998s44fz3lNYgAAAABAweJMDQAAABQabdu2VZs2bRQeHu5QnpKSok8++UTjx49XSEiIKlasqH79+mnWrFmX7G/x4sU6ceKEHnvssWsZNgAAAAAgj0hqAAAAoNCLi4tTenq6wyWkatWqpS1btuQ6zenTpzV48GC9/fbbBRAhAAAAACAvSGoAAACg0EtOTpa/v788Pf939dWQkBCdOXMm12meeeYZde3aVRUqVCiIEAEAAAAAecA9NQAAAFDoBQQEKCUlRRkZGfbExunTpxUYGOi0/S+//KLVq1dr06ZNBRkmAAAAAOA/kNQAAABAoVepUiV5eXlp8+bNql27tiQpNjZW1atXd9p++fLl2rt3ryIjIyVJaWlpOnfunMLDw7V161ZFREQUWOwAAAAAgP/h8lMAAAAoNDIyMpSamqqMjAxlZWUpNTVV6enp8vPzU/v27fX888/r9OnT+uuvvzR9+nQ98cQTTvsZPHiw/vzzT8XGxio2Nlbjxo1TpUqVFBsbq2LFihXwUgEAAAAAspHUAAAAQKExfvx4+fr6asKECVqyZIl8fX11zz33SJLeeOMNBQcHq1SpUmrQoIG6d++uzp0726dt0aKFXnzxRUlSUFCQSpUqZX+EhobKy8tLpUqVkoeHh0uWDQAAAADA5acAAABQiIwZM0ZjxoxxWhcUFKSPP/4412m//fbbXOu6du2qrl27XmV0AAAAAICrxZkaAAAAAAAAAADALZDUAAAAAAAAAAAAboGkBgAAAAAAAAAAcAskNQAAAAAAAAAAgFvgRuEAAAC4Jnbu3OnqEAqN8PBwRUdHuzoMAAAAAHA5khoAAADIV+dPH5NVUqdOnVwdSqHhZ7NpZ1wciQ0AAAAANzySGgAAAMhXGeeSlCXpjVoVVSHQz9XhuL2/zqSob+yfSkxMJKkBAAAA4IZHUgMAAADXRIVAP9UIDnB1GAAAAACAQoQbhQMAAAAAAAAAALdAUgMAAAAAAAAAALgFkhoAAAAAAAAAAMAtkNQAAAAAAAAAAABugaQGAAAAAAAAAABwCyQ1AAAAAAAAAACAWyCpAQAAAAAAAAAA3AJJDQAAAAAAAAAA4BZIagAAAAAAAAAAALdAUgMAAAAAAAAAALgFkhoAAAAAAAAAAMAtkNQAAAAAAAAAAABugaQGAAAAAAAAAABwCyQ1AAAAAAAAAACAWyCpAQAAAAAAAAAA3AJJDQAAAAAAAAAA4BZIagAAAAAAAAAAALdAUgMAAAAAAAAAALgFkhoAAAAAAAAAAMAtkNQAAAAAAAAAAABugaQGAAAAAAAAAABwCyQ1AAAAAAAAAACAWyCpAQAAAAAAAAAA3AJJDQAAAAAAAAAA4BZIagAAAAAAAAAAALdAUgMAAAAAAAAAALgFkhoAAAAAAAAAAMAtkNQAAAAAAAAAAABuodAmNd58802VKVNGNptN9erV0/r1610dEgAAAIBCiLEHAAAAUHAKZVLj008/1eDBgzV69Ght2rRJNWvWVLNmzZSQkODq0AAAAAAUIow9AAAAgIJVKJMaU6ZMUY8ePdStWzdVqVJFb7/9tvz8/PT++++7OjQAAAAAhQhjDwAAAKBgebo6gPyWnp6ujRs3asSIEfYyq9Wqpk2bas2aNU6nSUtLU1pamv356dOnJUmnTp1SVlbWtQ3YiTNnzshisSg1fptMWkqBz7+wST+8RxaLRVuSzio507g6HLe392yKLBaLzpw5o1OnTrk6nOsO22/+YvvNP2y7l8a2m7/YdvPX9bD9JiUlSZKM4fX8t8sde1yv4460nQkyKRkFPn/gWks/cMLln59Xiu0ThZ27bp9smyjsXL1t5nXcYTGFbGRy6NAhlSxZUr/99pvq169vL3/mmWe0cuVKrVu3Lsc0Y8aM0dixYwsyTAAAAMDt/P333ypVqpSrw7huXO7Yg3EHAAAA8N/+a9xR6M7UuBIjRozQ4MGD7c+zsrJ04sQJFSlSRBaLxYWRIT8kJSUpKipKf//9t4KCglwdDoDLwPYLuCe23cLHGKMzZ84oMjLS1aG4NcYd4PMRuD6xbQLXJ7bNG09exx2FLqkRHh4uDw8PHT161KH86NGjKlGihNNpfHx85OPj41AWEhJyrUKEiwQFBfEBCLgptl/APbHtFi7BwcGuDuG6c7ljD8YdyMbnI3B9YtsErk9smzeWvIw7Ct2Nwr29vVW7dm0tX77cXpaVlaXly5c7nBIOAAAAAFeDsQcAAABQ8ArdmRqSNHjwYHXp0kV16tRR3bp1NW3aNJ09e1bdunVzdWgAAAAAChHGHgAAAEDBKpRJjfbt2+vYsWMaNWqUjhw5olq1amnZsmUqXry4q0ODC/j4+Gj06NE5TvUHcP1j+wXcE9subiSMPXA5+HwErk9sm8D1iW0TubEYY4yrgwAAAAAAAAAAAPgvhe6eGgAAAAAAAAAAoHAiqQEAAAAAAAAAANwCSQ0AAAAAAAAAAOAWSGoAAAAAAAAAAAC3QFIDAOBSZcqU0bRp03Ktb9y4sQYOHFhg8QA3sjlz5igkJMTVYVxzN8pyAgCA/2HcARScG2V/+0ZZzusRSQ24pa5du8piseR4NG/eXCdOnFC/fv1UqVIl+fr6Kjo6Wv3799fp06ft0+/fv9/p9BaLRWvXrnXhkgHXl4u3tSJFiqh58+basmWLq0MDIGnNmjXy8PBQq1atLntaZwP79u3b688//8yn6HKX248GDAoAuCPGJsDVY9wBuBbjCrgbkhpwW82bN9fhw4cdHh9//LEOHTqkQ4cOadKkSdq2bZvmzJmjZcuWqXv37jn6+PHHH3P0Ubt2bRcsDXD9+ve2tnz5cnl6euree+91dVgAJM2aNUv9+vXTqlWrdOjQoavuz9fXV8WKFcuHyADgxsLYBLh6jDsA12FcAXdDUgNuy8fHRyVKlHB4hIaGqlq1avriiy/UunVr3XTTTbrrrrs0YcIELVmyRBkZGQ59FClSJEcfXl5eLloi4Pr0722tVq1aGj58uP7++28dO3ZMkjRs2DBVrFhRfn5+KleunJ5//nmdP3/eoY8lS5bo1ltvlc1mU3h4uB544IFc5/fee+8pJCREy5cvt5dlZGSob9++Cg4OVnh4uJ5//nkZY+z1J0+eVOfOnRUaGio/Pz+1aNFCf/31l70++yiN7777TjExMQoICLAPmi6ed0xMjGw2mypXrqwZM2Zc1boDrqXk5GR9+umneuqpp9SqVSvNmTMnR5vctr3GjRvrwIEDGjRokP2ISMn5EU1vvfWWbrrpJnl7e6tSpUr64IMPHOotFovee+89PfDAA/Lz81OFChX01Vdf5dtyLl68WLfccotsNpvKlSunsWPHOnyfT5kyRdWrV5e/v7+ioqLUu3dvJScnO/QxZ84cRUdHy8/PTw888ICOHz+eb/EBgMTYBMgPjDsA12BccQHjCvdCUgM3hNOnTysoKEienp6uDgVwa8nJyZo/f77Kly+vIkWKSJICAwM1Z84c7dixQ6+99ppmzpypqVOn2qf55ptv9MADD6hly5b6448/tHz5ctWtW9dp/6+88oqGDx+u77//Xnfffbe9fO7cufL09NT69ev12muvacqUKXrvvffs9V27dtWGDRv01Vdfac2aNTLGqGXLlg6DnJSUFE2aNEkffPCBVq1apfj4eA0ZMsRe/+GHH2rUqFGaMGGCdu7cqRdffFHPP/+85s6dm2/rD8hPCxYsUOXKlVWpUiV16tRJ77//vsOg+1Lb3sKFC1WqVCmNGzfOfkSkM4sWLdKAAQP09NNPa9u2berVq5e6deumFStWOLQbO3asHn74YW3ZskUtW7ZUx44ddeLEiatexl9++UWdO3fWgAEDtGPHDr3zzjuaM2eOJkyYYG9jtVr1+uuva/v27Zo7d65++uknPfPMM/b6devWqXv37urbt69iY2PVpEkTjR8//qpjA4ArxdgE+G+MO4CCw7jiAsYVbsYAbqhLly7Gw8PD+Pv7OzwmTJiQo+2xY8dMdHS0efbZZ+1l+/btM5KMr69vjj4A/M/F25okExERYTZu3JjrNK+++qqpXbu2/Xn9+vVNx44dc21funRpM3XqVPPMM8+YiIgIs23bNof6Ro0amZiYGJOVlWUvGzZsmImJiTHGGPPnn38aSWb16tX2+sTEROPr62sWLFhgjDFm9uzZRpLZvXu3vc2bb75pihcvbn9+0003mY8++shh3i+88IKpX79+rrEDrnT77bebadOmGWOMOX/+vAkPDzcrVqyw1+d12/u32bNnm+DgYId59OjRw6HNQw89ZFq2bGl/LsmMHDnS/jw5OdlIMt9++22u827UqJHx8vLK8R3s4+PjMP+7777bvPjiiw7TfvDBByYiIiLXvj/77DNTpEgR+/NHHnnEIV5jjGnfvr3DfADgajA2Aa4e4w7GHXAdxhXOMa64vnFoCNxWkyZN9NZbbzmUhYWFOTxPSkpSq1atVKVKFY0ZMyZHH59++qliYmKuZZiA2/v3tnby5EnNmDFDLVq00Pr161W6dGl9+umnev3117Vnzx4lJycrIyNDQUFB9uljY2PVo0ePS85j8uTJOnv2rDZs2KBy5crlqL/tttvsp7FKUv369TV58mRlZmZq586d8vT0VL169ez1RYoUUaVKlbRz5057mZ+fn2666Sb784iICCUkJEiSzp49qz179qh79+4OsWZkZCg4ODivqwooMHFxcVq/fr0WLVokSfL09FT79u01a9YsNW7cWFLetr3/snPnTvXs2dOhrEGDBnrttdccymrUqGH/39/fX0FBQfbtKzcdO3bUc88951C2cOFCvfjii/bnmzdv1urVqx2OoMrMzFRqaqpSUlLk5+enH3/8URMnTtSuXbuUlJSkjIwMh/qdO3fmuPRE/fr1tWzZsrytBADIA8YmwNVj3MG4AwWPcQXjCndFUgNuy9/fX+XLl8+1/syZM2revLkCAwO1aNEip9ejjYqKumQfAHJua++9956Cg4M1c+ZMtWrVSh07dtTYsWPVrFkzBQcH65NPPtHkyZPt7X19ff9zHnfeeae++eYbLViwQMOHD78my3HxZ4DFYrGfUpt9ncyZM2c6DFIkycPD45rEA1yNWbNmKSMjQ5GRkfYyY4x8fHz0xhtvKDg4OE/bXn5xtn1lZWVdcprg4OAc38EX30wwOTlZY8eOVdu2bXNMb7PZtH//ft1777166qmnNGHCBIWFhenXX39V9+7dlZ6eLj8/vytcIgC4PIxNgKvHuINxBwoe4wrGFe6Ke2qgUEpKStI999wjb29vffXVV7LZbK4OCSg0LBaLrFarzp07p99++02lS5fWc889pzp16qhChQo6cOCAQ/saNWo43HzPmbp16+rbb7/Viy++qEmTJuWoX7duncPztWvXqkKFCvLw8FBMTIwyMjIc2hw/flxxcXGqUqVKnpapePHiioyM1N69e1W+fHmHR9myZfPUB1BQMjIyNG/ePE2ePFmxsbH2x+bNmxUZGamPP/5Y0n9ve97e3srMzLzkvGJiYrR69WqHstWrV+d527pat9xyi+Li4nJsl+XLl5fVatXGjRuVlZWlyZMn67bbblPFihV16NChHMvg7DMEAAoKYxPgyjDuAK4txhWMK9wZZ2rAbaWlpenIkSMOZZ6envL29tY999yjlJQUzZ8/X0lJSUpKSpIkFS1a1OHoh+PHj+foIyQkhIEG8C//3tZOnjypN954Q8nJyWrdurWSkpIUHx+vTz75RLfeequ++eYb+2mr2UaPHq27775bN910kzp06KCMjAwtXbpUw4YNc2h3++23a+nSpWrRooU8PT01cOBAe118fLwGDx6sXr16adOmTZo+fbr9qKwKFSro/vvvV48ePfTOO+8oMDBQw4cPV8mSJXX//ffneTnHjh2r/v37Kzg4WM2bN1daWpo2bNigkydPavDgwVe49oD89/XXX+vkyZPq3r17jssUtGvXTrNmzdKTTz75n9temTJltGrVKnXo0EE+Pj4KDw/PMa+hQ4fq4Ycf1s0336ymTZtqyZIlWrhwoX788ccCWdZRo0bp3nvvVXR0tB588EFZrVZt3rxZ27Zt0/jx41W+fHmdP39e06dPV+vWrbV69Wq9/fbbDn30799fDRo00KRJk3T//ffru+++4xRxAPmOsQlw9Rh3MO5AwWJcwbjCrbn2lh7AlenSpYuRlONRqVIls2LFCqd1ksy+ffuMMf+7GZ+zx8cff+zahQOuIxdva4GBgebWW281n3/+ub3N0KFDTZEiRUxAQIBp3769mTp1ao4bZX3xxRemVq1axtvb24SHh5u2bdva6y6+qdjKlSuNv7+/ef31140xF2781bt3b/Pkk0+aoKAgExoaap599lmHG/idOHHCPPbYYyY4ONj4+vqaZs2amT///NNef/FNyowxZtGiRebir8EPP/zQHmdoaKhp2LChWbhw4ZWuPuCauPfee3PcoC7bunXrjCSzefNmY8ylt701a9aYGjVqGB8fH/u24GxbmTFjhilXrpzx8vIyFStWNPPmzXOol2QWLVrkUBYcHGxmz56d6zI0atTIDBgwIEe5s/kvW7bM3H777cbX19cEBQWZunXrmnfffddeP2XKFBMREWHf9ufNm2ckmZMnT9rbzJo1y5QqVcr4+vqa1q1bm0mTJnFDPwD5hrEJcPUYdzDuQMFjXMG4wp1ZjPm/C/sBAAAAAAAAAABcx7inBgAAAAAAAAAAcAskNQAAAAAAAAAAgFsgqQEAAAAAAAAAANwCSQ0AAAAAAAAAAOAWSGoAAAAAAAAAAAC3QFIDAAAAAAAAAAC4BZIaAAAAAAAAAADALZDUAAAAAAAAAAAAboGkBgAAAAAAAAAAcAskNQAAAAAAAAAAgFsgqQEAAAAAAAAAANwCSQ0AAAAAAAAAAOAWSGoAAAAAAAAAAAC3QFIDAAAAAAAAAAC4BZIaAAAAAAAAAADALZDUAAAAAAAAAAAAboGkBgAAAAAAAAAAcAskNQAUOhaLRY0bN3Z1GIVK165dZbFYtH///jy1//nnn2WxWDRmzJhrGtfVGDNmjCwWi37++ec8T8N7CwAAAP8lKSlJAwYMUNmyZeXl5SWLxaLY2FhXh1UolSlTRmXKlHF1GIXSnDlzZLFYNGfOnKvui3EUgPxGUgPAZdm/f78sFossFotKlCihjIwMp+127txpb8dOZsG76667ZLFYVK1aNVeHgjzKTgTl9ggJCXF1iAAAAIVW9jinefPmV93XM888o9dff13VqlXT8OHDNXr0aJUoUSIfoiy8/j3OzMvD3caYue3rBwYGqm7dupo6darOnz/v6jABwG14ujoAAO7J09NTR48e1dKlS3XfffflqJ81a5asVtfkTXfu3Ck/Pz+XzPt6sHfvXvtO8/bt27Vu3TrVq1evQGOoW7eudu7cqfDw8AKdb2FQu3Zt3XvvvTnKbTabC6IBAADA5fr6669VsWJFLVmyxNWhuI2QkBCNHj06R/nYsWMVHBysgQMH5mgvScuXLy+A6PLPv/f1MzMzdeTIES1ZskSDBw/Wb7/9ps8++8zFEQKAeyCpAeCK3H777dq8ebPef//9HEmNjIwMzZ8/X02bNtXKlSsLPLbKlSsX+DyvJ++//76MMRoyZIgmTZqkWbNmFXhSw8/P74Z/Ha5UnTp1ruvLdgEAAODSDh06pIYNG7o6DLcSEhLidB947NixudZJ0k033XRtA8tnzvb1T548qerVq+vzzz/X3r17Va5cOdcEBwBuhMtPAbgivr6+6tChg7755hslJCQ41H399dc6evSoHn/8cafTHjp0SKNHj9Ztt92mYsWKycfHR2XKlFHv3r1z9LV7924FBgaqVKlSOn78eJ7qnF2vM/ueEHv37tWkSZNUsWJF+fr6qkqVKvrkk08kSenp6XruuedUpkwZ2Ww21ahRQ99++22O+C913dbGjRvLYrE4lP373g2zZ89W9erV5evrq7Jly+r111+XJBljNHnyZFWqVEk2m00VKlTQvHnznM7jUjIzMzVnzhwVKVJEEyZMUPny5fXJJ5/o7NmzuU6zePFi3XPPPSpSpIhsNpvKlCmjxx57TNu2bcvR1hij119/XZUrV5aPj49Kly6tsWPHKisry6Hdpe6pkZCQoEGDBql8+fLy8fFReHi42rVrl2N+5cuXV2BgoFJSUpzGfd9998lisejPP/+UJJ0+fVovv/yyGjVqpMjISHl7eysyMlKdO3fWnj17LrneZs2aperVq8tms6lkyZIaNGiQzpw5c8lp/i09PV1TpkzRLbfcIn9/fwUGBurOO+/UV199lec+8urf76c5c+bolltukZ+fn8N7/syZMxo9erSqVq0qX19fhYSEqFmzZvr111+d9rl9+3bde++9CgwMVHBwsFq2bKlt27Y5vZfKpe5Fcqnr7m7ZskUdOnRQRESEvL29Vbp0afXr1y/Hdp196YGuXbtq9+7deuCBBxQaGip/f381bdpUmzdvdroMCQkJevrpp1WpUiX5+voqLCxM9erV06RJkyRJf/31l6xWq1q2bOl0+jNnziggIIBkHAAAcJC9P7Rv377/3A/ObmuM0cqVK+2XGLp4bLJ48WLdfffdCg0Nlc1mU7Vq1TRp0iRlZmY6tPv3vtWSJUvUoEEDBQYGOoxFLmc/9HKW5eJ48zJeKMh94mzOxmb5Pf661ssVGhpqPwgtMTHRoS77/XPw4EF17txZJUqUkNVqddgXX7VqlVq3bq3w8HD5+PioQoUKGjlyZI5xVHp6uqZPn65mzZopKipKPj4+KlasmNq2bas//vgjz/H+888/qlatmmw2m7744guHuvfee89eFxUVpWeeeUapqam59nXgwAF1795dJUuWlLe3t0qVKqXu3bsrPj7eod2gQYNksVi0YcMGh/I2bdrIYrGoU6dODuXZ49GxY8fay7LH6ufPn9eYMWNUpkwZ+fj4qGLFipoxY0aelx/AdcIAwGXYt2+fkWSaNWtm1q1bZySZSZMmObRp3bq1CQsLM6mpqcbHx8eULl3aof7jjz82/v7+5r777jP9+/c3Tz/9tLnrrruMJFOuXDlz6tQph/azZ882kkybNm3sZenp6aZOnTrGarWan376yaG9JNOoUSOHsi5duhhJ5v777zclSpQwPXr0ME8++aQJCQkxFovFLFu2zLRq1cqULVvW9O7d2zz++OPGZrMZLy8vs3v3boe+SpcunWOZsjVq1Mhc/NE6evRo+7yDg4NN586dTf/+/U3JkiWNJDNz5kzTu3dvU7x4cdO9e3fz1FNPmdDQUCPJrFy5MreXwqlvvvnGSDK9e/c2xhgzduxYI8nMnj3bafvBgwcbSSYsLMw8/vjjZvjw4aZjx46mRIkSZurUqTnWX7t27Ux4eLjp2rWr6d+/v4mOjjaSzLPPPuvQ74oVK4wkM3r0aIfy3bt3m1KlShlJ5p577jFPP/20eeyxx4yfn5/x9/c3a9euzbHePvzwwxxxHzt2zHh5eZl69erZy9asWWO8vb1Ns2bNTO/evc3QoUNN69atjYeHhwkLCzP79+936CO7/9atWxs/Pz/TrVs3M2zYMFO7dm0jydx2220mPT3dYRpn763U1FTTuHFjI8nUqlXL9OvXzzz55JMmKirKSDLTp093uu4vlr3OevXqdcl22XG3bNnS+Pr6mg4dOphhw4bZX4Pjx4+bqlWrGkmmQYMGZuDAgebxxx83RYoUMZ6enmbRokUO/W3dutUEBQUZq9VqHnzwQTNixAhz9913m6CgIHPnnXcaSWbfvn055r9ixYocsWVvqxe/3xYvXmx8fHzs8Q4dOtS0atXKSDIVKlQwJ06csLfN/oxp1KiRKVKkiGnYsKEZPHiwuf/++40kExoaao4cOeLQ/65du0xERISRZO644w7zzDPPmD59+pjGjRub0NBQe7u77rrLWK1WEx8fnyP2t99+20gyr7766iXXPwAAKJz+Pc75t8vZD160aJF9X6l06dJm9OjRZvTo0Q77RsOHDzeSTMmSJc3jjz9uBg0aZOrUqWMkmQcffNBh3tn7Vi1btjSenp6mTZs25plnnjFPPvmkMeby90Mvd5/emLyPF/Jrn/hi2esyN87GZvk5/iqIff2TJ0+aUqVKGX9//xxjYUmmWrVqJioqytSsWdMMGDDA9OrVy2zcuNEYY8yMGTOMxWIxoaGhpnPnzmbIkCH2eG+//XaTlpZm7+vw4cPGarWaRo0amZ49e5phw4aZhx56yPj4+BibzWbWr1/vMG9n+/Y7duwwUVFRJigoKMd4YNy4cUaSKV68uOnbt68ZNGiQiY6ONvfee6/TcVRcXJwpWrSofUw2fPhwe9uiRYuauLg4e9vFixcbSeaVV16xl2VmZtpft8jISIe+R40aleP1zB6rt2vXzkRFRZmePXuap556yhQpUsRIMu+++66TVw7A9YqkBoDLcvHOfrVq1UzVqlXt9YcPHzaenp6mX79+xhjjNKlx9OhRc+bMmRx9z50710gy48ePz1HXoUMHI8nMmDHDGGPM0KFDjSQzYsSIHG0vldSoWLGiSUhIsJdnJ2ZCQkLMHXfcYZKTk+11n376qZFkX5ZsV5rUCAsLM3v27LGXx8fHG29vbxMcHJwjrrVr19p37i5H27ZtjSSzZs0aY4wxe/bsMRaLxdxxxx052i5ZssRIMtWrVzeJiYkOdefPn3f44Th7/ZUtW9YcOnTIXn7s2DETEhJiAgMDHXaYc0tq3H777cbDw8MsW7bMoTwuLs4EBgaa6tWr28v++usvI8m0aNEiR+zTp083kswbb7xhLzt16pQ5fvx4jrY//fSTsVqt5oknnnAoz35dvL29zebNm+3lWVlZ5tFHH3WasHP23nr22WeNJPP888+brKwse3lSUpKpU6eO8fb2NgcPHswR18Wy11nt2rXtA+B/P3bu3OkQt7+/v9myZUuOfrJjnzlzpkP50aNHTVRUlClatKg5d+6cvTz7PTt//nyH9iNGjDCSrjqpkZiYaIKCgkzJkiVzJJY+/vhjI8n07dvXXpb9GSPJvPTSSw7tR44caSSZiRMnOpRn/xDgbCDy999/2//P3qbHjBmTo132a/Xv7RAAANw4/iupkdf9YGOc7zMaY8z3339vn8e/xx1ZWVnmySefNJLM559/bi/P3reyWq3mhx9+yNHf5e6HXu6yXM54Ib/2iS92NUmN/Bh/Xct9/eeff9706NHDREREmKCgIKcHc2XvF3fr1s1kZGQ41G3fvt14enqamjVr5nh9Jk6cmGM8k5qaav75558c89i2bZsJCAgwTZs2dSi/eN9+zZo1JiwszJQoUcLExsY6tP3rr7+Mp6enKVmypDl69Ki9/PTp06ZSpUpOt4kmTZoYSeadd95xKH/zzTeNJHPXXXfZy06ePGmsVqvD2HDjxo1Gkrn77ruNJIckyJ133ml8fX0d3s/Z45569eqZ06dP28t37dplPD09TaVKlXKsGwDXL5IaAC7LxTv7U6ZMMZLsR9i/9NJLRpL5448/jDHOkxq5ycrKMkFBQaZx48Y56k6dOmXKlCljfH19zeuvv24sFoupW7euOX/+fI62l0pqzJ07N0f7cuXKOT0qJyMjw3h5eZmGDRs6lF9pUmPs2LE52mefoZJbXNHR0U7n40xCQoLx8vIyFStWdCi/4447jCSza9cuh/IWLVoYSTnOdHEme/29//77udb9+wd2Z0mNTZs2GUnm8ccfdzqP7KPAtm7dai+rX7++8fT0dNgxNsaYunXrGi8vL3Ps2LH/jN0YY6pXr27KlCnjUJb9ulyc7DDGmP379xsPDw9TrVo1h/KL31vZRwfddNNNDoOcbF999VWej+DKXme5PbLPsMiOe9CgQTn6OHbsmPHw8HAYAPzb66+/biSZJUuWGGOMOXDggJFkatSokaPtmTNnTEhIyFUnNbI/I+bNm+c0pltuucWEh4fbn2d/xpQtW9ZkZmY6tM2ua9u2rb0sOzF58XbqTHp6uilevLgpXbq0Q9+bN282ksxDDz30n30AAIDC6b+SGnndDzYm96TGfffdZySZAwcO5Kg7deqUsVgspl27dvay7H2rBx54IEf7K9kPvdxlyet4IT/3iS92NUmNqx1/FdS+vsViMY899phDAiZb9kFYzsY9/fv3N5LMqlWrctRlZmaaokWLmtq1a/9nbMZcuNqCt7e3w5nq/963/+abb4yfn58pX7682bt3b47ps68QMHny5Bx1H3zwQY5tInscUqVKlRzrNjMz01SuXNlIcjjDunbt2iYgIMD+G8CkSZOMJLN69Wojybz11lvGGGNSUlKMt7d3jjFR9ljd2fs5uy4pKSkPawvA9YAbhQO4Kp06ddKwYcP0/vvvq169epo9e7Zuvvlm1apV65LTLVy4UO+88442bdqkkydPOlw/9tChQznaBwcH68MPP1TDhg3Vv39/BQYG6qOPPpKn5+V9jDmLKyIiQnv37s1R5+HhoWLFijmN50rkNu9L1a1bty7P/c+dO1fnz5/XY4895lDeuXNn/frrr3r//ff18ssv28vXr18vHx8fNWrUKM/zqF27do6yUqVKSZJOnTp1yWnXrl0rSTp69KjTe23s2rXL/rdatWqSpMcee0xr1qzRxx9/rAEDBki6cG+E9evX268b+28///yzpk2bpnXr1ikxMVEZGRn2Om9vb6dx3XnnnTnKSpcuraioKG3fvl3p6em5ThsXF6eTJ08qMjLS4Xqt2Y4dO+awbHnRq1cvvf322//Zrm7dujnKfv/9d2VmZiotLc3pOv7rr7/s8dx77732+1PccccdOdoGBASoVq1aTu+dcTmyX/d169Y5vbdJamqqEhMTlZiY6PB61qpVS1ar462/nL3X1q9fL0m65557/jMWLy8vdevWTS+99JK+//57NW/eXJI0c+ZMSVKPHj0uY8kAAMCN5Gr2g7OtXbtW/v7+ev/9953W+/r6Ot1vdLbfdzX7oXldlryOF67FPnF+uNrx17Xe1zfGKCEhQT/88IMGDhyob7/9VuvWrctxo/CyZcvmGPdI/9vP/u6777R8+fIc9V5eXjlii42N1SuvvKJff/1VR44c0fnz5x3qExMT7eso22effabvv//efs/JYsWK5ZhX9rjC2djKWVlsbKwkqVGjRjnuSWm1WtWwYUPt2rVLsbGxioqKkiQ1adJEGzdu1O+//6769etrxYoViomJ0e23367SpUtrxYoVevLJJ7V69Wqlp6erSZMmOeYr/ff7PzAw0Ol0AK4vJDUAXJWiRYuqdevW+uSTT/TQQw8pLi5O06dPv+Q0kydP1pAhQ1S0aFHdc889KlWqlHx9fSVJ06ZNU1pamtPpbrnlFpUuXVp79+5VixYtdNNNN112vEFBQTnKshMjudVdvKN3pa5k3v/+Uf6/zJo1SxaLJUdS4+GHH1b//v01b948TZgwwT7P06dPq2TJkjl+OL7SZbj4xoYXO3HihCTpm2++0TfffJNru3/f1Lx9+/YaOHCg5s+fb09qfPDBB5KUYzk/++wztW/fXgEBAWrWrJnKlCkjPz8/+80VDxw44HR+xYsXz7V8//79OnPmjIoUKXLJZdq+fbu2b9+ep2XKL87izo5n9erVWr169X/Gc/r0aUlyOjDJbR6XKzumN99885Ltzp496zBYy+t7LXsZSpYsmad4evbsqZdfflnvvfeemjdvrtTUVH344YcqW7asmjZtmqc+AADAjedq9oOznThxQhkZGU5/IM/mbL/xUvt9V7Ifejn7WXkZL7hyn/hSrnb8da2Xy2KxqHjx4urUqZNSU1PVo0cPTZw40X7ATbbc9smz45swYUKe5vfbb7/prrvuknThgKAKFSooICBAFotFX375pTZv3ux0LL5mzRplZGTozjvvzHXccKlxhbP4k5KScq2T/pd8ym4nXUhqTJo0SStWrFDdunX1yy+/2MeETZo00dKlSyVJK1assJc5kx/bMgDXI6kB4Kp1795dCxcuVNeuXWWz2dSxY8dc22ZkZOiFF15QRESEYmNjHXZ6jDF65ZVXcp126NCh2rt3r4oUKaIFCxaoS5cuatmyZb4uS15YrValp6c7rcvemStov/32m/0onDJlyjhtc+TIES1dulT33XefJCkkJERHjhxRVlbWZSU2rlT2zuP06dPVt2/fPE0TFhamli1b6ssvv1RcXJwqVaqk+fPnKzg4WK1bt3ZoO2bMGNlsNm3cuFEVKlRwqPvkk09yncfRo0dzLbdYLJc8Uid7mdq1a6fPP/88T8uUXy4+ounf8Tz99NOaNGnSf/YRHBwsSUpISHBa72zdZL9XnCXcnL3/s2PaunWr/Qyc/BQSEiJJOnjwYJ7aly1bVvfcc4+++uor+5FxJ0+e1NNPP+10nQIAAOSXoKAgWSwWJSYmXtZ0l9rvu5b7oXkdL7hyn/haKsjlqlevnqQLZ15fLLd91Oz4kpKS8nR2wYQJE5SWlqZffvklx5naa9eutZ9tcbEXX3xRX331lV577TV5eno6HWf8e1xRunRphzpnY4rs2HMbix05csShnXThjA9PT0+tWLFC/+///T8lJSXZExdNmjTRnDlztH37dv3888/y9/d3eoYTgMLj2v+KBaDQa9asmUqWLKmDBw+qTZs2Cg0NzbVtYmKiTp8+rfr16+c4imPDhg06d+6c0+m++eYbvfHGG2rUqJE2bNig0NBQdevWLdedoGspNDRUCQkJOX7UPXv2rP3yPgVt1qxZkqQWLVqoe/fuOR7t2rVzaCddOI09LS1NK1euLJAYs3fU16xZc1nTZR99M3/+fK1evVr79u3Tgw8+KJvN5tBuz549iomJyZHQOHz4sPbu3Ztr/7/88kuOsgMHDujvv/9W1apVc730lCTFxMQoKChIGzZsyLczeq7GrbfeKovFkud1XLNmTUnSr7/+mqMuOTnZflr4v2Vv386SCH/88UeOsit93fMqe7Dy/fff53maXr166fz585o7d67ee+89eXh4qFu3btckPgAAgGz16tXT8ePH82XMUBD7oXkdL1xv+8T5pSCX6+TJk5KkrKysPE+TvZ+dfRmq/7Jnzx6FhYXlSGikpKRo06ZNuU5ns9m0aNEitWrVSpMnT9bTTz+do032uMLZ2MpZWfblv1atWiVjjEOdMUarVq1yaCdJgYGBql27tlavXq1ly5bJYrHYkxrZZ6AsWbJEv//+u26//XZ5eXnlukwA3B9JDQBXzcPDQ19++aUWLVqkiRMnXrJtsWLF5Ovrq02bNiklJcVefvLkSfXr18/pNEeOHFG3bt0UGhqq+fPnq0yZMnr33XeVkJCgLl265NgJutZuvfVWnT9/Xh9++KG9zBijESNGFPgp1dKFH58XLFggf39/LViwQO+9916Ox4IFC1SqVCktXbrUftRLnz59JEkDBgywn7qcLSMjI98TRnXr1lW9evX08ccf69NPP81Rn5WV5XTA1KpVK4WGhurDDz/UvHnzJOW89JR04T4Yu3fvdog7NTVVTz311CUHIfPmzdOWLVvsz40xevbZZ5WZmamuXbtecpk8PT311FNP6cCBAxoyZIjT+Wzbti3XMyHyW4kSJfTwww/rt99+06uvvup021i3bp1924uOjlbDhg21ZcsWh/ezdOGILGfXh7711lslXVhv/x50rVmzJkcfktStWzcFBgbqueeec3rafkpKSp4HYs7ceuutuvXWW7Vq1aocp+pLzpMvrVu3VmRkpKZOnaqVK1eqVatWioyMvOIYAAAA8qJ///6SpMcff1zHjx/PUX/kyBHt3LkzT30VxH5oXscL19s+cX4pqOXKzMzUa6+9Jklq2LBhnqfr3bu3PD091a9fP8XHx+eoP3XqlMNBR6VLl9bJkycd9skzMzM1ZMgQ+/1BcuPj46OFCxfq3nvv1ZQpUzRo0CCH+kcffVQeHh6aMmWKw/pISkrS+PHjc/QXHR2tJk2aaPv27TnuMfPuu+9q586duuuuu+z308jWpEkTnTt3TtOnT1fNmjUVFhYm6cI9McqXL68pU6bo/PnzuV56CkDhweWnAOSLOnXqqE6dOv/Zzmq1qnfv3po8ebJq1qyp1q1bKykpSd9++61Kly6d44dFY4w6d+6sY8eO6fPPP7ffwOvBBx9U9+7dNWvWLE2ZMsXp0SLXSt++fTV79mw98cQT+uGHH1S0aFH98ssvOnXqlGrWrJnrabvXyqeffqrk5GR16dJFAQEBTttYrVZ17txZL774oubOnathw4apZcuWGjJkiCZNmqQKFSrogQceULFixXTw4EEtX75cQ4YM0cCBA/M11o8//lhNmjRRhw4dNG3aNN1yyy3y9fVVfHy81qxZo2PHjik1NdVhGh8fHz388MN65513NHv2bJUuXdrpzn6/fv3Ur18/3XzzzXrwwQeVkZGhH374QcaYS74uzZo1U/369dWhQwcVLVpUy5cv14YNG3Tbbbflmmj7t7Fjx2rTpk16/fXX9c0336hhw4b29bh161Zt3rxZa9asyfX6s/ltxowZiouL0zPPPKMPPvhA9evXV0hIiP7++29t2LBBf/31lw4fPiw/Pz9JF+510aBBA3Xu3FlffvmlKlSooPXr1+v333/XnXfemePIqttuu00NGjTQTz/9pPr166thw4Y6cOCAFi9erNatW2vRokUO7YsWLaqPP/5YDz30kGrWrKnmzZurcuXKSktL0/79+7Vy5UrdfvvtWrZs2RUv84cffqjGjRurZ8+e9mVOTU3V9u3b9ccff+T40cDT01Pdu3fXCy+8IIkbhAMAgILRvHlzPf/883rhhRdUvnx5NW/eXKVLl9bx48e1e/du/fLLLxo/frxiYmLy1N+13g+9nPHC9bZPnF/ye7k2bNigMWPG2J8nJCTop59+UlxcnKKjozVy5Mg8x1atWjXNmDFDTz31lCpVqqSWLVvqpptu0pkzZ7R3716tXLlSXbt2td+YvF+/fvr+++91xx136OGHH5bNZtPPP/+sgwcPqnHjxvr5558vOT9vb2998cUXeuihhzRt2jQZYzRt2jRJUvny5TVq1CiNHj1aNWrU0MMPPyxPT0998cUXqlGjhuLi4nL099Zbb+mOO+5Qjx49tGTJElWpUkXbt2/XV199paJFi+qtt97KMU2TJk300ksv6dixY+rUqVOOuuyDnEhqADcAAwCXYd++fUaSadasWZ7a+/j4mNKlSzuUpaenmwkTJpgKFSoYHx8fEx0dbZ5++mlz5swZU7p0aYf2r776qpFknnjiiRx9Jycnm4oVKxpvb2+zadMme7kk06hRI4e2Xbp0MZLMvn37cvTTqFEjk9vH4cXxZPvpp59MvXr1jI+PjylSpIh57LHHzNGjR532NXr0aCPJrFixIkc/VxrXv9WvXz/X/v/tzz//NJJMxYoVHcq/+OIL06RJExMcHGx8fHxMmTJlzGOPPWa2bduWpzidLd+KFSuMJDN69Ogc7U+cOGFGjhxpqlWrZnx9fU1AQICpUKGCefTRR83ChQudxv7rr78aSUaSGTFihNM2WVlZ5u233zZVq1Y1NpvNlChRwnTv3t0kJCT85+syc+ZMU7VqVePj42MiIiLMgAEDTFJSUo55OHtvGWNMRkaGeeedd0yDBg1MUFCQ/X3dvHlz89Zbb5nk5GSnMf9b9jrr1avXJdtd6v2ULSUlxbzyyiumdu3axt/f3/j6+pqyZcuaNm3amHnz5pnz5887tN+6datp2bKlCQgIMIGBgaZFixZm69atub7uiYmJpnPnziYsLMz4+vqa2267zXz33Xdm9uzZRpKZPXt2jph27dplunfvbkqXLm28vb1NaGioqV69uunfv79Zv369vV32Z0yXLl2cLltur8GRI0fMgAEDTLly5Yy3t7cJCwsz9erVM1OmTHHaz+7du40kU7JkSZORkZHrugQAADeG3MY5l7sfbEzu+yvZfvjhB9O6dWtTtGhR4+XlZUqUKGHq169vXnjhBRMfH29vd6l9q2yXsx96JctiTN7GC5cbS15Jcjoey+ZsvJbf46/83Ne/+GGz2UxMTIwZOnSoSUxMzDHdf72XjDFm/fr1pkOHDiYyMtJ4eXmZ8PBwc8stt5jhw4ebnTt3OrT9/PPPzS233GL8/PxMeHi4efjhh82ePXucrpfc3n/p6emmTZs2RpLp37+/Q93MmTNNlSpVjLe3tylVqpQZMmSISUlJyXU59u/fb7p162YiIiKMp6eniYiIMN26dTP79+93uqxnz541Xl5eRpJZsmSJQ91HH31kJJmAgIAc4x1jLj2+vtT7AsD1yWJMAV+3BQAAuIWuXbtq7ty52rdvX643oHdXn3/+uR566CE9//zzGjdunKvDAQAAAAAAecQ9NQAAwA3FGKPJkyfL09OTS08BAAAAAOBmuKcGAAC4IWzdulVff/21fvvtN61du1a9evXKcfNBAAAAAABwfSOpAQAAbggbN27Us88+q+DgYD322GOaNGmSq0MCAAAAAACXiXtqAAAAAAAAAAAAt8A9NQAAAAAAAAAAgFvg8lNOZGVl6dChQwoMDJTFYnF1OAAAAIBLGWN05swZRUZGymrluKj8wrgDAAAA+J+8jjtIajhx6NAhbhwKAAAAXOTvv/9WqVKlXB1GocG4AwAAAMjpv8YdJDWcCAwMlHRh5QUFBbk4GgAAAMC1kpKSFBUVZd9PRv7IXp8HDhxQSEiIa4O5wWVlZenYsWMqWrQoZyO5GK/F9YPX4vrBa3H94LW4fvBaXD/y87XI67jjukpqrFq1Sq+++qo2btyow4cPa9GiRWrTpo293hij0aNHa+bMmTp16pQaNGigt956SxUqVLC3OXHihPr166clS5bIarWqXbt2eu211xQQEJDnOLJP/Q4KCiKpAQAAAPwfLpGUvxh3XD+ysrKUmpqqoKAgfhhxMV6L6wevxfWD1+L6wWtx/eC1uH5ci9fiv8Yd19UrfvbsWdWsWVNvvvmm0/pXXnlFr7/+ut5++22tW7dO/v7+atasmVJTU+1tOnbsqO3bt+uHH37Q119/rVWrVqlnz54FtQgAAAAAAAAAAOAaua7O1GjRooVatGjhtM4Yo2nTpmnkyJG6//77JUnz5s1T8eLF9eWXX6pDhw7auXOnli1bpt9//1116tSRJE2fPl0tW7bUpEmTFBkZWWDLAgAAAAAAAAAA8td1ldS4lH379unIkSNq2rSpvSw4OFj16tXTmjVr1KFDB61Zs0YhISH2hIYkNW3aVFarVevWrdMDDzzgtO+0tDSlpaXZnyclJUm6cOpMVlbWNVoiAAAAwD2wTwwAAADgeuE2SY0jR45IkooXL+5QXrx4cXvdkSNHVKxYMYd6T09PhYWF2ds4M3HiRI0dOzZH+bFjxxwubfVvxhhlZmbKGHNZywHXsFgs8vDw4DrQAAAAV+DMmTOuDgEAAAAAJLlRUuNaGjFihAYPHmx/nn2X9aJFizq9YV96err279/PEWtuxmq1qkyZMvL29nZ1KAAAAG7FZrO5OgQAAAAAkORGSY0SJUpIko4ePaqIiAh7+dGjR1WrVi17m4SEBIfpMjIydOLECfv0zvj4+MjHxydHudVqzXHHdmOMjh49Kk9PT0VGRubbHd1xbWVlZenQoUM6evSooqOjOWMDAADgMrDPCwAAAOB64TZJjbJly6pEiRJavny5PYmRlJSkdevW6amnnpIk1a9fX6dOndLGjRtVu3ZtSdJPP/2krKws1atXL1/iyMjIUEpKiiIjI+Xn55cvfaJgFC1aVIcOHVJGRoa8vLxcHQ4AAAAAAAAA4DJdV4dcJScnKzY2VrGxsZIu3Bw8NjZW8fHxslgsGjhwoMaPH6+vvvpKW7duVefOnRUZGak2bdpIkmJiYtS8eXP16NFD69ev1+rVq9W3b1916NBBkZGR+RJjZmamJHEJIzeU/Zplv4YAAODGsWfPHrVo0UKhoaEqWbKkXnnlFYf69957T5UqVZK/v7/KlCmjxYsXuyhSAAAAAMClXFdnamzYsEFNmjSxP8++z0WXLl00Z84cPfPMMzp79qx69uypU6dO6Y477tCyZcscrvH74Ycfqm/fvrr77rtltVrVrl07vf766/keK5cvcj+8ZgAA3JgyMzN13333qU2bNvrqq6+0d+9e/b//9/9UqlQpPfroo3r33Xc1depUffLJJ6pVq5YSEhJ09uxZV4cNAAAAAHDiukpqNG7cWMaYXOstFovGjRuncePG5domLCxMH3300bUIDwAAAG4oLi5OcXFxGj16tLy8vFSpUiV1795d7777rtq3b69Ro0Zp3rx5uvnmmyVJxYsXd3HEAAAAAIDcXFdJDXcWHx+vxMTEAptfeHi4oqOjC2x+AAAA7iorK0uSHA6eycrK0pYtWxQXF6ejR49q06ZN6tmzpzIyMtSiRQtNnjxZQUFBrgoZAAAAAJALkhr5ID4+XpUqxyj1XEqBzdPm66e4XTsLZWJjzpw5GjhwoE6dOuXqUAAAQCFQqVIllSlTRqNGjdK4ceO0e/duvf/++0pKStKJEyckST/++KM2bNggSerQoYMGDRqkWbNmuTJsAAAAAIATJDXyQWJiolLPpahst0myRZS/5vNLPbxb+2YPUWJiYp6TGl27dtXcuXMlSV5eXoqOjlbnzp317LPPytMz97fBnDlz1K1bt0v2vW/fPpUpUybP8QMAABQkLy8vLV68WIMGDVLJkiVVqlQpdevWTe+8844CAgIkSSNGjFB4eLj9/0ceecSVIQMAAAAAckFSIx/ZIsrLP7qqq8PIVfPmzTV79mylpaVp6dKl6tOnj7y8vDRixIhcp2nfvr2aN29uf962bVtVq1bN4b4mRYsWzXMM6enp8vb2vrIFAAAAuEJVq1bV999/b38+bNgwNWrUSJUqVZLNZnNhZAAAAACAy2F1dQAoOD4+PipRooRKly6tp556Sk2bNtWCBQsUFBSkzz//3KHtl19+KX9/f2VkZKhEiRL2h7e3t/z8/OzP09PT1bZtWwUEBCgoKEgPP/ywjh49au9nzJgxqlWrlt577z2VLVvW/qPBqVOn1KtXLxUvXlw2m03VqlXT119/7RDDd999p5iYGAUEBKh58+Y6fPjwtV9JAACgUNqyZYvOnj2r9PR0LVy4UO+//75GjhwpX19fderUSS+//LJOnjypU6dO6eWXX9b999/v6pABAAAAAE6Q1LiB+fr6ymq1qkOHDpo9e7ZD3ezZs/Xggw8qMDAw1+mzsrJ0//3368SJE1q5cqV++OEH7d27V+3bt3dot3v3bn3xxRdauHChYmNjlZWVpRYtWmj16tWaP3++duzYoZdeekkeHh72aVJSUjRp0iR98MEHWrVqleLj4zVkyJD8XQEAAOCGsWDBAkVHRys0NFSTJk3Sl19+qRo1akiSpk2bpsjISJUtW1aVKlVS6dKlNWXKFBdHDAAAAABwhstP3YCMMVq+fLm+++479evXTw899JBuv/12HT58WBEREUpISNDSpUv1448/XrKf5cuXa+vWrdq3b5+ioqIkSfPmzVPVqlX1+++/69Zbb5V04ZJT8+bNs1+m6vvvv9f69eu1c+dOVaxYUZJUrlw5h77Pnz+vt99+WzfddJMkqW/fvg6XvAIAALgc48eP1/jx453W+fv7a86cOQUbEAAAAADginCmxg3k66+/VkBAgGw2m1q0aKH27dtrzJgxqlu3rqpWrWq/kfj8+fNVunRpNWzY8JL97dy5U1FRUfaEhiRVqVJFISEh2rlzp72sdOnSDvfdiI2NValSpewJDWf8/PzsCQ1J9mQLAAAAAAAAAODGRVLjBtKkSRPFxsbqr7/+0rlz5zR37lz5+/tLkp544gn7EYqzZ89Wt27dZLFY8mW+2fPI5uvr+5/TeHl5OTy3WCwyxuRLPAAAAAAAAAAA90RS4wbi7++v8uXLKzo6Wp6ejlce69Spkw4cOKDXX39dO3bsUJcuXf6zv5iYGP3999/6+++/7WU7duzQqVOnVKVKlVynq1Gjhv755x/9+eefV74wAAAAAAAAAIAbDvfUyEeph3e77XxCQ0PVtm1bDR06VPfcc49KlSr1n9M0bdpU1atXV8eOHTVt2jRlZGSod+/eatSokerUqZPrdI0aNVLDhg3Vrl07TZkyReXLl9euXbtksVjUvHnz/FwsAAAAAAAAAEAhQlIjH4SHh8vm66d9s4cU2Dxtvn4KDw/P1z67d++ujz76SI8//nie2lssFi1evFj9+vVTw4YNZbVa1bx5c02fPv0/p/3iiy80ZMgQPfLIIzp79qzKly+vl1566WoXAQAAXCfi4+OVmJjo6jAKjfDwcEVHR7s6DFwjCY+0VKqnh6vDuKEZi0WnosrK/L1PFi57e9m+Dnw2/zqzGHlHGKUftkgmfy6JfDneaVThmvX9e6/y16xvAABuJCQ18kF0dLTidu0s0IH75Q5ss++XcSkHDx5UkSJFdP/99+fa5ueff3Z4Hh0drcWLF+fafsyYMRozZkyO8rCwML3//vtOp+natau6du3qUNamTRvuqQEAgJuIj49XTKVKSklNdXUohYafzaadcXEkNgAAAADc8Ehq5JPo6Gi3HWSmpKTo8OHDeumll9SrVy95e3u7OiQAAODGEhMTlZKaqjdqVVSFQD9Xh+P2/jqTor6xfyoxMdFt9zcBAAAAIL+Q1IBeeeUVTZgwQQ0bNtSIESNcHQ4AACgkKgT6qUZwgKvDAAAAAAAUIlZXBwDXGzNmjM6fP6/ly5crIIAfHgAAAAAAAAAA1yeSGgAAAAAAAAAAwC2Q1AAAAAAAAAAAAG6BpAYAAAAAAAAAAHALJDUAAAAAAAAAAIBbIKkBAAAAAAAAAADcgqerAygs4uPjlZiYWGDzCw8PV3R0dIHNDwAAAAAAAAAAVyOpkQ/i4+MVU6mSUlJTC2yefjabdsbF5SmxYbFYLlk/evRojRkzJp8iyz9lypTRgQMHJEm+vr666aabNGDAAD3xxBPq2rWr5s6dm+u0pUuX1v79+wsoUgAAAAAAAABAQSCpkQ8SExOVkpqqN2pVVIVAv2s+v7/OpKhv7J9KTEzMU1Lj8OHD9v8//fRTjRo1SnFxcfaygICAaxLnlUpPT5e3t7ckady4cerRo4dSUlL02WefqUePHipZsqRee+01vfTSS/ZpIiIiNHv2bDVv3lyS5OHh4ZLYAQAAAAAAAADXDvfUyEcVAv1UIzjgmj8uN3FSokQJ+yM4OFgWi8Wh7JNPPlFMTIxsNpsqV66sGTNm2Kfdv3+/LBaLFi5cqCZNmsjPz081a9bUmjVr7G0OHDig1q1bKzQ0VP7+/qpataqWLl1qr1+5cqXq1q0rHx8fRUREaPjw4crIyLDXN27cWH379tXAgQMVHh6uZs2a2esCAwNVokQJlStXTsOGDVNYWJh++OEHBQcHOyyDJIWEhNifFy1a9LJfPwAAAAAAAADA9Y0zNW5wH374oUaNGqU33nhDN998s/744w/16NFD/v7+6tKli73dc889p0mTJqlChQp67rnn9Mgjj2j37t3y9PRUnz59lJ6erlWrVsnf3187duywn/1x8OBBtWzZUl27dtW8efO0a9cu9ejRQzabzeGSV3PnztVTTz2l1atXO40zKytLixYt0smTJ+1ncQAAAAAAAAAAbiwkNW5wo0eP1uTJk9W2bVtJUtmyZbVjxw698847DkmNIUOGqFWrVpKksWPHqmrVqtq9e7cqV66s+Ph4tWvXTtWrV5cklStXzj7djBkzFBUVpTfeeEMWi0WVK1fWoUOHNGzYMI0aNUpW64WThSpUqKBXXnklR3zDhg3TyJEjlZaWpoyMDIWFhemJJ564ZusDAAAAAAAAAHD94vJTN7CzZ89qz5496t69uwICAuyP8ePHa8+ePQ5ta9SoYf8/IiJCkpSQkCBJ6t+/v8aPH68GDRpo9OjR2rJli73tzp07Vb9+fYeblTdo0EDJycn6559/7GW1a9d2GuPQoUMVGxurn376SfXq1dPUqVNVvnz5q194AAAAAAAAAIDbIalxA0tOTpYkzZw5U7GxsfbHtm3btHbtWoe2Xl5e9v+zExRZWVmSpCeeeEJ79+7VY489pq1bt6pOnTqaPn36ZcXi7+/vtDw8PFzly5fXnXfeqc8++0z9+/fXjh07LqtvAAAAAAAAAEDhQFLjBla8eHFFRkZq7969Kl++vMOjbNmyl9VXVFSUnnzySS1cuFBPP/20Zs6cKUmKiYnRmjVrZIyxt129erUCAwNVqlSpy55H+/btNWLEiMuaDgAAAAAAAABQOHBPjRvc2LFj1b9/fwUHB6t58+ZKS0vThg0bdPLkSQ0ePDhPfQwcOFAtWrRQxYoVdfLkSa1YsUIxMTGSpN69e2vatGnq16+f+vbtq7i4OI0ePVqDBw+230/jcgwYMEDVqlXThg0bVKdOncueHgAAAAAAAADgvkhq5KO/zqS43XyeeOIJ+fn56dVXX9XQoUPl7++v6tWra+DAgXnuIzMzU3369NE///yjoKAgNW/eXFOnTpUklSxZUkuXLtXQoUNVs2ZNhYWFqXv37ho5cuQVxVulShXdc889GjVqlJYuXXpFfQAAAAAAAAAA3BNJjXwQHh4uP5tNfWP/LLB5+tlsCg8Pv+zpunbtqq5duzqUPfroo3r00Uedti9TpozDpaMkKSQkxKHsv+6f0ahRI61fvz7X+p9//tlp+f79+52WL1u2LEfZxTECAAAAAAAAAAofkhr5IDo6Wjvj4pSYmFhg8wwPD1d0dHSBzQ8AAAAAAAAAAFcjqZFPoqOjSTIAAAAAAAAAAHANXf6dmgEAAAAAAAAAAFyApAYAAAAAAAAAAHALJDWuEDemdj+8ZgAAAAAAAADg3khqXCYPDw9JUnp6uosjweXKfs2yX0MAAAAAAAAAgHvhRuGXydPTU35+fjp27Ji8vLxktZIXcgdZWVk6duyY/Pz85OnJ2x4AAAAAAAAA3BG/7l4mi8WiiIgI7du3TwcOHHB1OLgMVqtV0dHRslgsrg4FAAAAAAAAAHAFSGpcAW9vb1WoUIFLULkZb29vzqwBAAAAAAAAADdGUuMKWa1W2Ww2V4cBAAAAAAAAAMANg8PWAQAAAAAAAACAWyCpAQAAAAAAAAAA3AJJDQAAAAAAAAAA4BZIagAAAAAAAAAAALdAUgMAAAAAAAAAALgFkhoAAAAAAAAAAMAtkNQAAAAAAAAAAABugaQGAAAAAAAAAABwCyQ1AAAAAAAAAACAWyCpAQAAAAAAAAAA3AJJDQAAAAAAAAAA4BZIagAAAAAAAAAAALdAUgMAAAAAAAAAALgFkhoAAAAAAAAAAMAtkNQAAAAAAAAAAABugaQGAAAAAAAAAABwCyQ1AAAAAAAAAACAWyCpAQAAAAAAAAAA3AJJDQAAAAAAAAAA4BZIagAAAAAAAAAAALdAUgMAAAAAAAAAALgFkhoAAAAAAAAAAMAtkNQAAAAAAAAAAABugaQGAAAAAAAAAABwCyQ1AAAAAAAAAACAWyCpAQAAAAAAAAAA3AJJDQAAAAAAAAAA4BZIagAAAAAAAAAAALdAUgMAAAAAAAAAALgFkhoAAAAAAAAAAMAtkNQAAAAAAAAAAABugaQGAAAAAAAAAABwCyQ1AAAAAAAAAACAWyCpAQAAAAAAAAAA3AJJDQAAAAAAAAAA4BZIagAAAAAAAAAAALdAUgMAAAAAAAAAALgFkhoAAAAAAAAAAMAtkNQAAAAAAAAAAABugaQGAAAAAAAAAABwCyQ1AAAAAAAAAACAWyCpAQAAAAAAAAAA3AJJDQAAAAAAAAAA4BZIagAAAAC4piwWyyUfY8aMcXWITpUpU8Yeo5+fn6pXr6733ntPktS1a9dLLlOZMmVcGzwAAABQSHm6OgAAAAAAhdvhw4ft/3/66acaNWqU4uLi7GUBAQGuCCtX6enp8vb2liSNGzdOPXr0UEpKij777DP16NFDJUuW1GuvvaaXXnrJPk1ERIRmz56t5s2bS5I8PDxcEjsAAABQ2HGmBgAAAIBrqkSJEvZHcHCwLBaLQ9knn3yimJgY2Ww2Va5cWTNmzLBPu3//flksFi1cuFBNmjSRn5+fatasqTVr1tjbHDhwQK1bt1ZoaKj8/f1VtWpVLV261F6/cuVK1a1bVz4+PoqIiNDw4cOVkZFhr2/cuLH69u2rgQMHKjw8XM2aNbPXBQYGqkSJEipXrpyGDRumsLAw/fDDDwoODnZYBkkKCQmxPy9atGiO9ZCWlqakpCSHBwAAAIDLw5kaAAAAAFzmww8/1KhRo/TGG2/o5ptv1h9//KEePXrI399fXbp0sbd77rnnNGnSJFWoUEHPPfecHnnkEe3evVuenp7q06eP0tPTtWrVKvn7+2vHjh32sz8OHjyoli1bqmvXrpo3b5527dqlHj16yGazOVz2au7cuXrqqae0evVqp3FmZWVp0aJFOnnypP0sjss1ceJEjR079oqmBQAAAHABSQ0AAAAALjN69GhNnjxZbdu2lSSVLVtWO3bs0DvvvOOQ1BgyZIhatWolSRo7dqyqVq2q3bt3q3LlyoqPj1e7du1UvXp1SVK5cuXs082YMUNRUVF64403ZLFYVLlyZR06dEjDhg3TqFGjZLVeOHm9QoUKeuWVV3LEN2zYMI0cOVJpaWnKyMhQWFiYnnjiiSta1hEjRmjw4MH250lJSYqKirqivgAAAIAbFZefAgAAAOASZ8+e1Z49e9S9e3cFBATYH+PHj9eePXsc2taoUcP+f0REhCQpISFBktS/f3+NHz9eDRo00OjRo7VlyxZ72507d6p+/fqyWCz2sgYNGig5OVn//POPvax27dpOYxw6dKhiY2P1008/qV69epo6darKly9/Rcvr4+OjoKAghwcAAACAy+NWSY3MzEw9//zzKlu2rHx9fXXTTTfphRdekDHG3sYYo1GjRikiIkK+vr5q2rSp/vrrLxdGDQAAAMCZ5ORkSdLMmTMVGxtrf2zbtk1r1651aOvl5WX/PztBkZWVJUl64okntHfvXj322GPaunWr6tSpo+nTp19WLP7+/k7Lw8PDVb58ed1555367LPP1L9/f+3YseOy+gYAAACQf9wqqfHyyy/rrbfe0htvvKGdO3fq5Zdf1iuvvOIwYHnllVf0+uuv6+2339a6devk7++vZs2aKTU11YWRAwAAALhY8eLFFRkZqb1796p8+fIOj7Jly15WX1FRUXryySe1cOFCPf3005o5c6YkKSYmRmvWrHE4EGr16tUKDAxUqVKlLnse7du314gRIy5rOgAAAAD5x63uqfHbb7/p/vvvt19Lt0yZMvr444+1fv16SRfO0pg2bZpGjhyp+++/X5I0b948FS9eXF9++aU6dOjgtN+0tDSlpaXZnyclJUm6cORX9tFfAAAAyBtjjKxWq4zFKvOvS/7gyhiL9cL6NMZl+6bXcr5jx45V//79FRwcrObNmystLU0bNmzQyZMnHe4/cSkDBw5UixYtVLFiRZ08eVIrVqxQTEyMJKl3796aNm2a+vXrp759+youLk6jR4/W4MGD7ffTuBwDBgxQtWrVtGHDBtWpU+eypwcAAABwddwqqXH77bfr3Xff1Z9//qmKFStq8+bN+vXXXzVlyhRJ0r59+3TkyBE1bdrUPk1wcLDq1aunNWvW5JrUmDhxosaOHZuj/NixY5zhAQAAcJlSU1NVu3ZtZZUtq1P+NleH4/aywlJV+5yHUlNT7feQKGhnzpy5Zn0/8cQT8vPz06uvvqqhQ4fK399f1atX18CBA/PcR2Zmpvr06aN//vlHQUFBat68uaZOnSpJKlmypJYuXaqhQ4eqZs2aCgsLU/fu3TVy5MgrirdKlSq65557NGrUKC1duvSK+gAAAABw5dwqqTF8+HAlJSWpcuXK8vDwUGZmpiZMmKCOHTtKko4cOSLpwmns/1a8eHF7nTMjRoxwOAosKSlJUVFRKlq0KDfvAwAAuEwHDx7Uxo0bZfXNVEiw8/sUIO+sp89q48ZY2Ww2FStWzCUx2Gz5l5zq2rWrunbt6lD26KOP6tFHH3XavkyZMg6XjpKkkJAQh7L/un9Go0aN7Gd3O/Pzzz87Ld+/f7/T8mXLluUouzhGAAAAANeGWyU1FixYoA8//FAfffSRqlatqtjYWA0cOFCRkZHq0qXLFffr4+MjHx+fHOVWq/WKTkkHAAC4kVksFmVlZclismThh96rZjEXLolqsVhctm/KPjEAAACA64VbJTWGDh2q4cOH2y8jVb16dR04cEATJ05Uly5dVKJECUnS0aNHFRERYZ/u6NGjqlWrlitCBgAAAAAAAAAA+cStDrlKSUnJcZSYh4eH/caFZcuWVYkSJbR8+XJ7fVJSktatW6f69esXaKwAAAAAAAAAACB/udWZGq1bt9aECRMUHR2tqlWr6o8//tCUKVP0+OOPS7pwqYOBAwdq/PjxqlChgsqWLavnn39ekZGRatOmjWuDBwAAAAAAAAAAV8WtkhrTp0/X888/r969eyshIUGRkZHq1auXRo0aZW/zzDPP6OzZs+rZs6dOnTqlO+64Q8uWLcvXmxsCAAAAAAAAAICC51ZJjcDAQE2bNk3Tpk3LtY3FYtG4ceM0bty4ggsMAAAAAAAAAABcc251Tw0AAAAAAAAAAHDjIqkBAAAAAAAAAADcAkkNAAAAAAAAAADgFkhqAAAAAAAAAAAAt0BSAwAAAAAAAAAAuAWSGgAAAAAAAAAAwC2Q1AAAAAAAAAAAAG6BpAYAAAAAAAAAAHALJDUAAAAAAAAAAIBbIKkBAAAAAAAAAADcAkkNAAAAAAAAAADgFkhqAAAAAAAAAAAAt0BSAwAAAAAAAAAAuAWSGgAAAAAAAAAAwC2Q1AAAAAAAAAAAAG6BpAYAAAAAAAAAAHALJDUAAAAAAAAAAIBbIKkBAAAAAAAAAADcAkkNAAAAAAAAAADgFkhqAAAAAAAAAAAAt0BSAwAAAAAAAAAAuAWSGgAAAAAAAAAAwC2Q1AAAAAAAAAAAAG6BpAYAAAAAAAAAAHALJDUAAAAAAAAAAIBbIKkBAAAAAAAAAADcAkkNAAAAAAAAAADgFkhqAAAAAAAAAAAAt0BSAwAAAAAAAAAAuAWSGgAAAAAAAAAAwC2Q1AAAAAAAAAAAAG6BpAYAAAAAAAAAAHALJDUAAAAAAAAAAIBbIKkBAAAAAAAAAADcAkkNAAAAAAAAAADgFkhqAAAAAAAAAAAAt0BSAwAAAAAAAAAAuAWSGgAAAAAAAAAAwC2Q1AAAAAAAAAAAAG6BpAYAAAAAAAAAAHALJDUAAAAAAAAAAIBbIKkBAAAAAAAAAADcAkkNAAAAAAAAAADgFkhqAAAAAAAAAAAAt0BSAwAAAAAAAAAAuAWSGgAAAAAAAAAAwC2Q1AAAAAAAAADw/9u78zgby/+P4+9zZt/tZiaGsWTJTtaikCFrVAiNJUWDkCW+CFlKSPYlGWulb4gWZRdZR4lokojs+zZmPffvj37Ot2NmGOPMnDkzr+fjcR4P93Xdy+c+l3u297nvCwCcAqEGAAAAAAAAAABwCoQaAAAAAAAAAADAKRBqAAAAAAAAAAAAp0CoAQAAAAAAAAAAnAKhBgAAAAAAAAAAcAqEGgAAAAAAAAAAwCkQagAAAAAAAAAAAKdAqAEAAAAAAAAAAJwCoQYAAAAAAAAAAHAKhBoAAAAAAAAAAMApEGoAAAAAAAAAAACnQKgBAAAAAAAAAACcAqEGAAAAAAAAAABwCoQaAAAAAAAAAADAKRBqAAAAAAAAAAAAp0CoAQAAAAAAAAAAnAKhBgAAAAAAAAAAcAqEGgAAAAAAAAAAwCm4OroAAAAAAMjJCnzyjXLlyuXoMnI0i8Ui0/nzKlCggMxmPvv3oF6x474sFovOO3As7HkuAAAgY/DTGgAAAAAAAAAAcAqEGgAAAAAAAAAAwCkQagAAAAAAAAAAAKdAqAEAAAAAAAAAAJwCoQYAAAAAAAAAAHAKhBoAAAAAAAAAAMApEGoAAAAAAAAAAACnQKgBAAAAAAAAAACcAqEGAAAAAAAAAABwCoQaAAAAAAAAAADAKRBqAAAAAAAAAAAAp0CoAQAAAAAAAAAAnAKhBgAAAAAAAAAAcAqEGgAAAAAAAAAAwCkQagAAAAAAAAAAAKdAqAEAAAAAAAAAAJwCoQYAAAAAAAAAAHAKhBoAAAAAAAAAAMApuKZno/3792v79u06dOiQLl68KJPJpHz58qlMmTKqXbu2KlWqZOcyAQAAAAAAAABATpfmUOP8+fOaOXOmFi1apL/++kuGYcjd3V25c+eWYRi6evWq4uPjZTKZFBISovDwcPXs2VMFCxbMyPoBAAAAAAAAAEAOkabHTw0ePFjFihXT3Llz1axZM61atUp///23YmNjdebMGZ09e1axsbH6+++/tWrVKjVr1kzz5s1T8eLFNWTIkIw+BwAAAAAAAAAAkAOk6U6NrVu3asmSJWrZsqVMJlOq6wUHBys4OFjNmzfX1KlT9eWXX2rChAl2KxYAAAAAAAAAAORcaQo1duzY8cA7NplMatWqlVq1avXA2wIAAAAAAAAAANwtTY+fAgAAAAAAAAAAcLR0hRrFihVTrVq1FB0dnWL/l19+qWLFij1UYQAAAAAAAAAAAP+WrlDj+PHj2rdvn6pXr65Vq1Yl679586b++uuvh60tRadOnVLHjh2VN29eeXl5qXz58tq7d6+13zAMjRgxQkFBQfLy8lLDhg115MiRDKkFAAAAAAAAAABknnQ/fmry5MmqW7eu2rRpo+HDh9uzplRduXJFderUkZubm7799lsdOnRIkyZNUu7cua3rTJgwQVOnTtXs2bO1a9cu+fj4KCwsTLGxsZlSIwAAAAAAAAAAyBhpmig8Jblz59aaNWs0evRojR49Wvv27dOyZcsUEBBgz/psvPfeeypcuLAWLFhgbQsNDbX+2zAMTZkyRcOGDVPLli0lSYsWLVLBggW1atUqtWvXLsNqAwAAAAAAAAAAGSvdocYdI0aMUPXq1dWxY0c9/vjjWrlypT3qStHq1asVFhamF154QVu2bNEjjzyi119/Xd27d5ckHTt2TGfPnlXDhg2t2wQEBKhGjRrasWNHqqFGXFyc4uLirMvXr1+XJFksFlkslgw7HwAAgOzIMAyZzWYZJrMMk8nR5Tg9w2T+5/00DIf9bMrPxAAAAACyiocONSSpcePG2rNnj1q3bq2aNWuqSZMm9thtMn/++admzZql/v37a+jQodqzZ4/69Okjd3d3hYeH6+zZs5KkggUL2mxXsGBBa19Kxo8fr1GjRiVrv3DhAo+tAgAAeECxsbGqWrWqLKGhuurj6ehynJ4lT6yq3nZRbGyszp8/75Aabty44ZDjAgAAAMDd7BJqSP88BmrHjh167bXXtHjxYpky4FN5FotF1apV07hx4yRJlStX1sGDBzV79myFh4ene79DhgxR//79rcvXr19X4cKFlT9/fvn7+z903QAAADnJqVOnFBUVJbNXknIF+Di6HKdnvnZLUVE/y9PTUwUKFHBIDZ6ehFMAAAAAsoZ0hRqbNm1SmTJlkrV7enpq4cKFatu2rS5cuPDQxd0tKChIZcuWtWkrU6aMvvjiC0lSYGCgJOncuXMKCgqyrnPu3DlVqlQp1f16eHjIw8MjWbvZ/M+t/gAAAEg7k8kki8Uik2GRyTAcXY7TMxn/PBLVZDI57GdTfiYGAAAAkFWkK9SoV6/ePfufffbZdBVzP3Xq1FF0dLRN2++//64iRYpI+udukcDAQG3YsMEaYly/fl27du1Sz549M6QmAAAAAAAAAACQOdIcauzbt++Bd16lSpUH3uZe+vXrp9q1a2vcuHF68cUXtXv3bs2dO1dz586V9M+nAvv27asxY8aoZMmSCg0N1fDhwxUcHKxWrVrZtRYAAAAAAAAAAJC50hxqVKtWLc3zZBiGIZPJpKSkpHQXlpLHH39cK1eu1JAhQzR69GiFhoZqypQp6tChg3WdQYMG6datW3r11Vd19epVPfHEE1q7di3PAQYAAAAAAAAAwMmlOdRYsGCBzfKNGzfUp08fDRw4MNk8FxmpWbNmatasWar9JpNJo0eP1ujRozOtJgAAAAAAAAAAkPHSHGqEh4fbLF+6dEl9+vRRWFiY6tevb/fCAAAAAAAAAAAA/s3s6AIAAAAAAAAAAADSglADAAAAAAAAAAA4BUINAAAAAAAAAADgFAg1AAAAAAAAAACAU0jzROF9+vSxWY6NjZXJZNL06dO1atWqZOubTCZ9+OGHD10gAAAAAAAAAACA9AChxvTp01NsTynQkAg1AAAAAAAAAACAfaU51LBYLBlZBwAAAAAAAAAAwD0xpwYAAAAAAAAAAHAKhBoAAAAAAAAAAMAppCnUKFu2rBYtWqT4+Pg07zguLk4LFixQ2bJl010cAAAAAAAAAADAHWmaU6Nz587q37+/3njjDbVo0UINGzZUlSpVFBoaKm9vb0nSrVu3dOzYMe3du1fr16/XmjVr5O7uroEDB2boCQAAAAAAAAAAgJwhTaHGoEGD1LNnT82fP1+RkZFavHixTCbTPztw/WcXiYmJkiTDMFSuXDmNGjVKXbt2lb+/fwaVDgAAAAAAAAAAcpI0hRqS5Ofnp759+6pv3746fvy4fvzxR/3222+6dOmSJClv3rwqXbq0atWqpdDQ0AwrGAAAAAAAAAAA5ExpDjX+rWjRoipatKidSwEAAAAAAAAAAEhdmiYKBwAAAAAAAAAAcDRCDQAAAAAAAAAA4BQINQAAAAAAAAAAgFMg1AAAAAAAAAAAAE6BUAMAAAAAAAAAADiFdIUaZ86csXcdAAAAAAAAAAAA95SuUKNw4cJq1KiRFi9erFu3btm7JgAAAAAAAAAAgGTSFWqMHj1ap0+fVnh4uAoWLKiOHTtq7dq1slgs9q4PAAAAAAAAAABAUjpDjaFDh+rgwYOKiopSjx49tHnzZj377LMKDg5Wv379tHfvXnvXCQAAAAAAAAAAcriHmii8cuXKmjhxok6ePKl169apadOmWrBggWrUqKGyZctq3LhxOnHihL1qBQAAAAAAAAAAOdhDhRp3mEwmPfnkk3r22WdVs2ZNGYahI0eOaOTIkSpWrJheeOEFJhcHAAAAAAAAAAAP5aFDjU2bNumVV15RwYIF9eKLL+rs2bOaOHGi/v77b505c0bvvvuuNmzYoE6dOtmjXgAAAAAAAAAAkEO5pmej/fv3a+nSpfrkk090+vRpBQYG6pVXXtHLL7+s8uXL26w7YMAAeXp6asCAAXYpGAAAAAAAAAAA5EzpCjUqV64sLy8vtWrVSi+//LKeeeYZmc2p3/Tx2GOPqVatWukuEgAAAAAAAAAAIF2hxscff6znn39evr6+aVr/6aef1tNPP52eQwEAAAAAAAAAAEhKZ6jRuXNnO5cBAAAAAAAAAABwb+maKHzq1KkKCwtLtb9JkyaaNWtWuosCAAAAAAAAAAC4W7pCjfnz56ts2bKp9pctW1Zz585Nd1EAAAAAAAAAAAB3S1eocfToUZUpUybV/tKlS+vo0aPpLgoAAAAAAAAAAOBu6Qo13N3ddfbs2VT7z5w5I7M5XbsGAAAAAAAAAABIUbqSh5o1ayoyMlI3btxI1nft2jUtWLBANWvWfOjiAAAAAAAAAAAA7nBNz0Zvv/226tWrp0qVKqlv37567LHHJEkHDx7UlClTdObMGS1btsyuhQIAAAAAAAAAgJwtXaFGjRo1tGbNGr322mt64403ZDKZJEmGYSg0NFSrV69WrVq17FooAAAAAAAAAADI2dIVakjSM888oz/++EM//fSTdVLw4sWLq0qVKtaQAwAAAAAAAAAAwF7SHWpIktlsVtWqVVW1alV71QMAAAAAAAAAAJCihwo1Dh06pD///FNXrlyRYRjJ+l9++eWH2T0AAAAAAAAAAIBVukKNo0ePqmPHjtq9e3eKYYYkmUwmQg0AAAAAAAAAAGA36Qo1XnvtNR04cEBTpkzRk08+qdy5c9u7LgAAAAAAAAAAABvpCjW2b9+uoUOHqnfv3vauBwAAAAAAAAAAIEXm9GyUL18+BQQE2LsWAAAAAAAAAACAVKUr1OjRo4eWLFmipKQke9cDAAAAAAAAAACQonQ9furRRx9VUlKSKlasqK5du6pw4cJycXFJtl7r1q0fukAAAAAAAAAAAAApnaFG27Ztrf8eMGBAiuuYTCbu5AAAAAAAAAAAAHaTrlBj06ZN9q4DAAAAAAAAAADgntIVatSrV8/edQAAAAAAAAAAANxTukKNO+Li4rRv3z6dP39ederUUb58+exVFwAAAAAAAAAAgA1zejecOnWqgoKC9MQTT6h169b65ZdfJEkXL15Uvnz59PHHH9utSAAAAAAAAAAAgHSFGgsWLFDfvn3VuHFjzZ8/X4ZhWPvy5cun+vXr69NPP7VbkQAAAAAAAAAAAOkKNSZNmqSWLVtq2bJlat68ebL+qlWr6tdff33o4gAAAAAAAAAAAO5IV6jxxx9/qEmTJqn258mTR5cuXUp3UQAAAAAAAAAAAHdLV6iRK1cuXbx4MdX+Q4cOKTAwMN1FAQAAAAAAAAAA3C1docazzz6ruXPn6urVq8n6fv31V82bN08tWrR42NoAAAAAAAAAAACs0hVqjBkzRklJSSpXrpyGDRsmk8mkhQsXqmPHjqpWrZoKFCigESNG2LtWAAAAAAAAAACQg6Ur1AgODlZUVJQaN26szz77TIZhaPHixVqzZo3at2+vnTt3Kl++fPauFQAAAAAAAAAA5GCu6d2wQIEC+uijj/TRRx/pwoULslgsyp8/v8zmdOUkAAAAAAAAAAAA95TuUOPf8ufPb4/dAAAAAAAAAAAApCpdocbo0aPvu47JZNLw4cPTs3sAAAAAAAAAAIBk0hVqjBw5MtU+k8kkwzAINQAAAAAAAAAAgF2lawIMi8WS7JWYmKijR4+qX79+qlatms6fP2/vWgEAAAAAAAAAQA5mt1m9zWazQkNDNXHiRJUsWVK9e/e2164BAAAAAAAAAADsF2r8W926dfXNN99kxK4BAAAAAAAAAEAOlSGhxt69e2U2Z8iuAQAAAAAAAABADpWuicIXLVqUYvvVq1e1detWrVixQq+88spDFQYAAAAAAAAAAPBv6Qo1OnfunGpfvnz59NZbb2nEiBHprQkAAAAAAAAAACCZdIUax44dS9ZmMpmUO3du+fn5PXRRAAAAAAAAAAAAd0tXqFGkSBF71wEAAAAAAAAAAHBPzOYNAAAAAAAAAACcQrru1DCbzTKZTA+0jclkUmJiYnoOBwAAAAAAAAAAkL5QY8SIEVq1apV+/fVXhYWFqVSpUpKk3377Td9//73KlSunVq1a2bNOAAAAAAAAAACQw6Ur1AgODtb58+d18OBBa6Bxx+HDh1W/fm5MlssAAFJDSURBVH0FBwere/fudikSAAAAAAAAAAAgXXNqvP/+++rVq1eyQEOSypQpo169emnChAkPXRwAAAAAAAAAAMAd6Qo1/v77b7m5uaXa7+bmpr///jvdRQEAAAAAAAAAANwtXaFGuXLlNHPmTJ06dSpZ399//62ZM2eqfPnyD10cAAAAAAAAAADAHemaU+ODDz5QWFiYHn30UT333HMqUaKEJOnIkSNatWqVDMPQkiVL7FooAAAAAAAAAADI2dIVajzxxBPatWuXhg8frpUrV+r27duSJC8vL4WFhWnUqFHcqQEAAAAAAAAAAOwqXaGG9M8jqFauXCmLxaILFy5IkvLnzy+zOV1PtAIAAAAAAAAAALindIcad5jNZnl6esrX15dAAwAAAAAAAAAAZJh0pxB79+5V48aN5e3trbx582rLli2SpIsXL6ply5bavHmzvWoEAAAAAAAAAABIX6jx448/6oknntCRI0fUsWNHWSwWa1++fPl07do1zZkzx25FAgAAAAAAAAAApCvUGDp0qMqUKaNDhw5p3Lhxyfqffvpp7dq166GLAwAAAAAAAAAAuCNdocaePXvUpUsXeXh4yGQyJet/5JFHdPbs2YcuDgAAAAAAAAAA4I50hRpubm42j5y626lTp+Tr65vuogAAAAAAAAAAAO6WrlCjZs2a+u9//5ti361bt7RgwQLVq1fvoQoDAAAAAAAAAAD4t3SFGqNGjdLevXvVtGlTffvtt5Kk/fv366OPPlLVqlV14cIFDR8+3K6FAgAAAAAAAACAnM01PRvVqFFD33zzjXr27KmXX35ZkvTmm29KkooXL65vvvlGFSpUsF+VAAAAAAAAAAAgx3vgUMMwDN24cUO1a9dWdHS0fv75Zx05ckQWi0XFixdX1apVU5w8HAAAAAAAAAAA4GE8cKgRHx+vPHnyaNy4cRo0aJAqVaqkSpUqZUBpAAAAAAAAAAAA//PAc2p4eHgoMDBQHh4eGVHPA3n33XdlMpnUt29fa1tsbKwiIiKUN29e+fr6qk2bNjp37pzjigQAAAAAAAAAAHaRronCO3furEWLFik+Pt7e9aTZnj17NGfOnGRzd/Tr109r1qzR559/ri1btuj06dNq3bq1g6oEAAAAAAAAAAD2kq6JwsuXL69Vq1bpscceU+fOnVW0aFF5eXklWy+jwoSbN2+qQ4cOmjdvnsaMGWNtv3btmubPn69ly5apfv36kqQFCxaoTJky2rlzp2rWrJni/uLi4hQXF2ddvn79uiTJYrHIYrFkyDkAAABkV4ZhyGw2yzCZZTDX2kMzTOZ/3k/DcNjPpvxMDAAAACCrSFeo0b59e+u/hw8fnuI6JpNJSUlJ6avqPiIiItS0aVM1bNjQJtSIiopSQkKCGjZsaG0rXbq0QkJCtGPHjlRDjfHjx2vUqFHJ2i9cuKDY2Fj7nwAAAEA2Fhsbq6pVq8oSGqqrPp6OLsfpWfLEquptF8XGxur8+fMOqeHGjRsOOS4AAAAA3C1docamTZvsXUeaffrpp9q3b5/27NmTrO/s2bNyd3dXrly5bNoLFiyos2fPprrPIUOGqH///tbl69evq3DhwsqfP7/8/f3tVjsAAEBOcOrUKUVFRcnslaRcAT6OLsfpma/dUlTUz/L09FSBAgUcUoOnJ+EUAAAAgKwhzaHG0KFD1a5dO1WoUEH16tXLyJpSdfLkSb3xxhtat26dXX+x8vDwSHHic7P5n1v9AQAAkHYmk0kWi0UmwyKTYTi6HKdnMv55JKrJZHLYz6b8TAwAAAAgq0jzbyfvvvuuDh48aF2+dOmSXFxctHHjxgwpLCVRUVE6f/68qlSpIldXV7m6umrLli2aOnWqXF1dVbBgQcXHx+vq1as22507d06BgYGZVicAAAAAAAAAALC/dD1+6g4jkz9516BBAx04cMCmrUuXLipdurQGDx6swoULy83NTRs2bFCbNm0kSdHR0Tpx4oRq1aqVqbUCAAAAAAAAAAD7eqhQI7P5+fmpXLlyNm0+Pj7Kmzevtb1bt27q37+/8uTJI39/f/Xu3Vu1atVKdZJwAAAAAAAAAADgHJwq1EiLDz74QGazWW3atFFcXJzCwsI0c+ZMR5cFAAAAAAAAAAAe0gOFGsePH9e+ffskSdeuXZMkHTlyRLly5Upx/SpVqjxcdWmwefNmm2VPT0/NmDFDM2bMyPBjAwAAAAAAAACAzPNAocbw4cM1fPhwm7bXX3892XqGYchkMikpKenhqgMAAAAAAAAAAPh/aQ41FixYkJF1AAAAAAAAAAAA3FOaQ43w8PCMrAMAAAAAAAAAAOCezI4uAAAAAAAAAAAAIC0INQAAAAAAAAAAgFMg1AAAAAAAAAAAAE6BUAMAAAAAAAAAADgFQg0AAAAAAAAAAOAUCDUAAAAAAAAAAIBTINQAAAAAAAAAAABOgVADAAAAAAAAAAA4BUINAAAAAAAAAADgFAg1AAAAAAAAAACAUyDUAAAAAAAAAAAAToFQAwAAAAAAAAAAOAVCDQAAAAAAAAAA4BQINQAAAAAAAAAAgFNwdXQBAAAAAJCTnW//rGJdXRxdRo5mmEy6WjhUxsljMhmGo8vJtr7yG3r/lUyG3IMMxZ8xSYYp44tC6hiLrIOxyDoYi6wjh47FnHolM2zfe14rkWH7tjfu1AAAAAAAAAAAAE6BUAMAAAAAAAAAADgFQg0AAAAAAAAAAOAUCDUAAAAAAAAAAIBTINQAAAAAAAAAAABOgVADAAAAAAAAAAA4BUINAAAAAAAAAADgFAg1AAAAAAAAAACAUyDUAAAAAAAAAAAAToFQAwAAAAAAAAAAOAVCDQAAAAAAAAAA4BQINQAAAAAAAAAAgFMg1AAAAAAAAAAAAE6BUAMAAAAAAAAAADgFQg0AAAAAAAAAAOAUCDUAAAAAAAAAAIBTINQAAAAAAAAAAABOgVADAAAAAAAAAAA4BUINAAAAAAAAAADgFAg1AAAAAAAAAACAUyDUAAAAAAAAAAAAToFQAwCANIiLi1P37t0VGhoqPz8/lS5dWh9//LG1/9ChQ2rQoIFy586twMBAvfrqq4qJiXFgxQAAAAAAANkPoQYAAGmQmJiooKAgrV+/XtevX1dkZKTefPNNff/995Kkl156SaVKldK5c+d04MAB7d+/X++8846DqwYAAAAAAMheCDUAAEgDHx8fjR49WsWLF5fJZFLNmjX19NNPa9u2bZKkP//8Ux07dpS7u7vy58+vFi1a6MCBAw6uGgAAAAAAIHsh1AAAIB1iY2O1e/duVahQQZI0YMAALVq0SLdv39bZs2e1cuVKNW/e3MFVAgAAAAAAZC+EGgAAPCDDMPTKK6+oZMmSat26tSSpSZMm2rZtm/z8/BQUFKTChQura9euDq4UAAAAAAAgeyHUAADgARiGoddff13R0dFatWqVzGazrly5ooYNG6p79+6KiYnR5cuX5ePjo44dOzq6XAAAAAAAgGzF1dEFAADgLAzDUEREhHbt2qUNGzYoICBAknT06FHdvn1bffr0kclkkru7u1577TU1adLEwRUDAAAAAABkL9ypAQBAGvXq1Uvbt2/XunXrlDt3bmt76dKl5evrq5kzZyoxMVE3btzQvHnzVLlyZQdWCwAAAAAAkP0QagBANhYXF6fu3bsrNDRUfn5+Kl26tD7++GObdT766COVKlVKPj4+Klq0qL788ksHVZu1/fXXX5o5c6aio6NVpEgR+fr6ytfXVz169JCvr6/WrFmjTz75RPny5VPRokV19epVLVy40NFlAwAAAAAAZCs8fgoAsrHExEQFBQVp/fr1KlasmHbt2qUmTZqoUKFCatSokebOnasPPvhAn376qSpVqqTz58/r1q1bji47SypSpIgMw0i1v06dOtq2bVsmVgQAAAAAAJDzEGoAQDbm4+Oj0aNHW5dr1qypp59+Wtu2bVODBg00YsQILVq0yPqYpIIFCzqqVAAAAAAAAOC+ePwUAOQgsbGx2r17typUqKDo6GidO3dO+/btU9GiRVWoUCF1795d169fd3SZAAAAAAAAQIoINQAghzAMQ6+88opKliyp1q1b6/Lly5Kk9evXa+/evfr555917Ngx9evXz8GVAgAAAAAAACnj8VMAkAMYhqHXX39d0dHRWr9+vcxms3x9fSVJQ4YMUb58+az/bt++vSNLBQAAAAAAAFJFqAEA2ZxhGIqIiNCuXbu0YcMGBQQESJJKlSolT09PB1cHAAAAAAAApB2hBgBkc7169dL27du1ceNG5c6d29ru5eWljh076r333lOVKlVkMpn03nvvqWXLlg6sNrkTJ07o4sWLji4jW8iXL59CQkIcXQYAAAAAAEC6EWoAQDb2119/aebMmfLw8FCRIkWs7R07dtTs2bM1ZcoURUREKDQ0VB4eHmrRooUmT57swIptnThxQmVKlVJMbKyjS8kWvD09dTg6mmADAAAAAAA4LUINAMjGihQpIsMwUu338fFRZGRk5hX0gC5evKiY2FhNr/SoSvp5O7ocp3bkRox6/fy7Ll68SKgBAAAAAACcFqEGACDLK+nnrQoBvo4uAwAAAAAAAA5mdnQBAAAAAAAAAAAAaUGoAQAAAAAAAAAAnAKhBgAAAAAAAAAAcAqEGgAAAAAAAAAAwCkwUTgA2NmJEyd08eJFR5eRLRw+fNjRJQAAAAAAACALIdQAADs6ceKESpUuo9jbMY4uBQAAAAAAAMh2CDUAwI4uXryo2NsxCu0yUZ5BJRxdjtO7dmCzTq+Z4ugyAAAAAAAAkEUQagBABvAMKiGfkMccXYbTu332qKNLAAAAAAAAQBbCROEAAAAAAAAAAMApEGoAAAAAAAAAAACnQKgBAAAAAAAAAACcAqEGAAAAAAAAAABwCoQaAAAAAAAAAADAKRBqAAAAAAAAAAAAp0CoAQAAAAAAAAAAnAKhBgAAAAAAAAAAcAqEGgAAAAAAAAAAwCkQagAAAAAAAAAAAKdAqAEAAAAAAAAAAJwCoQYAAAAAAAAAAHAKhBoAAAAAAAAAAMApEGoAAAAAAAAAAACnQKgBAAAAAAAAAACcAqEGAAAAAAAAAABwCoQaAAAAAAAAAADAKRBqAAAAAAAAAAAAp0CoAQAAAAAAAAAAnAKhBgAAAAAAAAAAcAqEGgAAAAAAAAAAwCkQagAAAAAAAAAAAKdAqAEAAAAAAAAAAJwCoQaQyaZPn65q1arJw8NDrVq1suk7dOiQGjRooNy5cyswMFCvvvqqYmJiHFMoAAAAAAAAAGQxhBpAJgsODtawYcPUvXv3ZH0vvfSSSpUqpXPnzunAgQPav3+/3nnnHQdUCQAAAAAAAABZD6EGkMlat26tVq1aKV++fMn6/vzzT3Xs2FHu7u7Knz+/WrRooQMHDjigSgAAANxLZGSkcuXK5egyAAAAgBzHqUKN8ePH6/HHH5efn58KFCigVq1aKTo62mad2NhYRUREKG/evPL19VWbNm107tw5B1UMPJgBAwZo0aJFun37ts6ePauVK1eqefPmji4LAAAgU3Tu3Fkmk0kmk0nu7u4qUaKERo8ercTExHtuFxkZad0utdfx48cz5yQAAAAAZCinCjW2bNmiiIgI7dy5U+vWrVNCQoIaNWqkW7duWdfp16+f1qxZo88//1xbtmzR6dOn1bp1awdWDaRdkyZNtG3bNvn5+SkoKEiFCxdW165dHV0WAABApmncuLHOnDmjI0eO6M0339TIkSP1/vvv33Obtm3b6syZM9ZXrVq11L17d5u2woULp7mG+Pj4hz0NAAAAABnE1dEFPIi1a9faLEdGRqpAgQKKiopS3bp1de3aNc2fP1/Lli1T/fr1JUkLFixQmTJltHPnTtWsWTPF/cbFxSkuLs66fP36dUmSxWKRxWLJoLNBTmcYhgzDsP4fu3Lliho2bKhRo0apR48eunXrlvr06aMOHTro008/dXC1SCvDMGQ2m2WWZJLh6HKcntkkmc1mGSazDJPJ0eU4NcNk/ue9/NfXHSCj3PlayLVrH1nh+s3M43p4eCgwMFCS1LNnT61cuVLLly/X+PHj9fHHH+v555+3rrtq1Sp16NBBZ8+etW4jSe7u7vL29ra2nThxQq1bt9aGDRtkNpvVuHFjTZs2TQULFpQkjRw5UqtWrVKvXr00duxY/fXXX7JYLLp69aoGDx6sVatW6dq1aypRooTeffddNWvWzHqs7777Tn379tXJkyf1xBNPaMGCBQoKCsqMtwoAAADIkZwq1LjbtWvXJEl58uSRJEVFRSkhIUENGza0rlO6dGmFhIRox44dqYYa48eP16hRo5K1X7hwQbGxsRlQOSDdunVLcXFxOn/+vCTp559/1u3bt9W2bVtdvXpVkvTCCy+oQ4cO1nWQ9cXGxqpq1aoqlEvy9Ljp6HKcXoEC3spbtaosoaG66uPp6HKcmiVPrKredlFsbCxfU5Dh7nwt5Nq1j6xw/d64ccMhx5UkLy8vmc1mtWvXTgsWLLAJNe4s+/n5pbq9xWJRy5Yt5evrqy1btigxMVERERFq27atNm/ebF3vjz/+0BdffKEVK1bIxcVFFotFTZo00Y0bN7RkyRIVL15chw4dkouLi3WbmJgYTZw4UYsXL5bZbFbHjh01YMAALV26NMVaUvswFQAAAIC0c9pQw2KxqG/fvqpTp47KlSsnSTp79qzc3d2TTdhXsGBBnT17NtV9DRkyRP3797cuX79+XYULF1b+/Pnl7++fIfUj50pMTFRiYqI8PDzk5uYmf39/mc1m1a5dW76+vvriiy/06quv6vbt2/riiy9UpUoVFShQwNFlI41OnTqlqKgoxTwjefv7Orocp3fpfIyOR0XJ7JWkXAE+ji7HqZmv3VJU1M/y9PTkawoy3J2vhVy79pEVrl9Pz8wPpwzD0IYNG/Tdd9+pd+/eeuGFF1S7dm2dOXNGQUFBOn/+vL755hutX7/+nvvZsGGDDhw4oGPHjlkfQbVo0SI99thj2rNnjx5//HFJ/zxyatGiRcqfP78k6fvvv9fu3bt1+PBhPfroo5KkYsWK2ew7ISFBs2fPVvHixSVJvXr10ujRo1OtJbUPUwEAAABIO6cNNSIiInTw4EFt27btoffl4eEhDw+PZO1m8z+3+gP2NG7cOJtfZn18fFSvXj1t3rxZa9as0eDBgzVs2DC5uLioTp06WrhwIf8PnYjJZPrn0XWSDPHIlYdlMf4JsU2GRSaDx3k9DJPxzyMVTSYTX1OQ4e58LeTatY+scP1m5nG/+uor+fr6KiEhQRaLRS+99JJGjhwpHx8fPfbYY1q4cKHeeustLVmyREWKFFHdunXvub/Dhw+rcOHCNnNqlC1bVrly5dLhw4etoUaRIkWsgYb0z120hQoVsgYaKfH29rYGGpKsYUtqUvswFQAAAIC0c8pQo1evXvrqq6+0detWFSpUyNoeGBio+Ph4Xb161eZujXPnztk8YxdwpJEjR2rkyJEp9tWpU8cuQR0AAICzevrppzVr1iy5u7srODhYrq7/+5XllVde0YwZM/TWW29pwYIF6tKli0x2mrfFx8f2riIvL6/7buPm5mazbDKZZNwjyEvtw1QAAAAA0s6pPqppGIZ69eqllStXauPGjQoNDbXpr1q1qtzc3LRhwwZrW3R0tE6cOKFatWpldrkAAAAAHpCPj49KlCihkJAQm0BDkjp27Ki//vpLU6dO1aFDhxQeHn7f/ZUpU0YnT57UyZMnrW2HDh3S1atXVbZs2VS3q1Chgv7++2/9/vvv6T8ZAAAAAHbnVHdqREREaNmyZfryyy/l5+dnnScjICBAXl5eCggIULdu3dS/f3/lyZNH/v7+6t27t2rVqpXqJOEAAAAAnEPu3LnVunVrDRw4UI0aNbK5azs1DRs2VPny5dWhQwdNmTJFiYmJev3111WvXj1Vq1Yt1e3q1aununXrqk2bNpo8ebJKlCih3377TSaTSY0bN7bnaQEAAAB4AE51p8asWbN07do1PfXUUwoKCrK+PvvsM+s6H3zwgZo1a6Y2bdqobt26CgwM1IoVKxxYNQAAAAB76datm+Lj49W1a9c0rW8ymfTll18qd+7cqlu3rho2bKhixYrZ/A6Rmi+++EKPP/642rdvr7Jly2rQoEFKSkp62FMAAAAA8BCc6k6Nez2f9g5PT0/NmDFDM2bMyISKAAAAANhLZGTkfdc5deqU8ubNq5YtW6a6zubNm22WQ0JC9OWXX6a6fmpznuXJk0cff/xxitt07txZnTt3tmlr1apVmn5nAQAAAJB+ThVqAOl14sQJXbx40dFlZBv58uVTSEiIo8sAAAA5SExMjM6cOaN3331Xr732mtzd3R1dEgAAAAAHINRAtnfixAmVKVVKMbGxji4l2/D29NTh6GiCDQAAkGkmTJigsWPHqm7duhoyZIijywEAAADgIIQayPYuXryomNhYTa/0qEr6eTu6HKd35EaMev38uy5evEioAQAAMk1qj4gCAAAAkLMQaiDHKOnnrQoBvo4uAwAAAAAAAACQTmZHFwAAAAAAAAAAAJAWhBoAAAAAAAAAAMApEGoAAAAAAAAAAACnQKgBAAAAAAAAAACcAqEGAAAAAAAAAABwCoQaAAAAAAAAAADAKRBqAAAAAAAAAAAAp0CoAQAAAAAAAAAAnAKhBgAAAAAAAAAAcAqEGgAAAAAAAAAAwCkQagAAAAAAAAAAAKdAqAEAAAAAAAAAAJwCoQYAAAAAAAAAAHAKhBoAAAAAAAAAAMApEGoAAAAAAAAAAACnQKgBAAAAAAAAAACcgqujCwAAAAAAAAAAZF9mN5PcfM2SyV57NOTmZ8gUa5Idd5rlFfRMyrB9x8bGpms7i8WihIQExcbGymy+9z0Ubm5ucnFxSddx/o1QAwAAAAAAAACQIQrW8Fb+8j4yu9oz1JBMLpKRcX/jz5L6e8Rl2L6PHTuWru0Mw5DFYtGNGzdkMt1/gHPlyqXAwMA0rZsaQg0AAAAAAAAAgN0VrOGt4Gr+ypMnn9xdPWSyY6phcjVkJOacuzQk6bKPe4btOzSPR7q2MwxDiYmJcnV1vWdQYRiGYmJidP78eUlSUFBQuo4nEWoAAAAAAAAAAOzM7G5S/vI+ypMnn3w9/O2+f5OrIcPIWaGG2S19wUNaeHp6pmu7tIYakuTl5SVJOn/+vAoUKJDuR1ExUTgAAAAAAAAAwK7cfMwyu5rl7ppxf4iH8/H29pYkJSQkpHsfhBoAAABZ0PTp01WtWjV5eHioVatWNn3Dhw9X+fLl5erqqr59+zqkPgAAAAC4p/+fw9uej5yC83uYuTTuINQAAADIgoKDgzVs2DB17949WV+JEiU0YcIEtWjRwgGVAQAAAADgOIQaAAAAWVDr1q3VqlUr5cuXL1lfeHi4mjRpIn9/+z+XFgAAAACQ8arWLa85C2am2t/qpaYa9s5bmViR82CicAAAAAAAAABApkh6o1mmHs/lw68eeJveA3vqsxWfWJdz58qtSuWraMRbo/RY6XL2LA/pwJ0aAAAAAAAAAAD8S/26DXVgZ7QO7IzWfxd/KVdXV3V8pZ2jy4IINQAAAAAAAAAAsOHu7q6C+QuqYP6CKl+2gnr36KtTZ/7WxUsXJUmj33tbNRtUVZHHglTtqYp6d/IYJSQk2Ozjuw3fqlGrp1W4TEGVrlZM4T06pHq8JZ8tUolKIdq6fYu1LTEpSW+NHKjiFUNUuloxTX13lAzDsPZfu3pFQyK6qVbJIFUtkkevtWupv/78w9q/8tPFqlkiUNs2rlPzOpVUrWg+vdq2hS6cO2Nz7P8uWaAyZcrI09NTpUuX1syZqT8WKysg1AAAAAAAAAAAIBU3b93Uf1ctV2iRYsqTO48kydfHV1MnzNQP3+3U2OHvavFnizT74/+FAes2fafOPTuqwVPPaMOarfrv4i9VpWLVFPc/bc6HGvP+SC1fuFJ169Sztn+24hO5urjou5UbNGb4u1o0e6r+u2SBtf8/fV7Vwf37NH3x51r69WYZhqEe7VvZhCu3b8cocuYUjZ8xX4tWr9OZUyf1/ttDrP1f/fcTTX9vtMaOHavDhw9r3LhxGj58uBYuXGi398/emFMDAAAgC0pMTLS+LBaLYmNjZTab5e7uroSEBCUlJVlfsbGxcnFxkZubm6PLBgAAAIBsYd2m71S0/COSpJiYWypYIFBL530qs/mf+wT69xpoXTekUBG9/sofWvXVF+r92huSpA9mTFKrZm00uO9Q63rlypRPdpzR772tz1d9plXLvlbpR8vY9D0S9IjeGTZeJpNJJYqVVNSxaC2aM00vdOqqv/78Q5vWfqUlX21U5eq1JEkTZi1Qg8oltfHb1Qpr0UaSlJiQoBHvT1NIaDFJ0ktde2jWpPHWY0yfMEYDR72r1q1bS5JCQ0N16NAhzZkzR+Hh4Q/3JmYQQg0AAIAsaMyYMRo1apR12cvLS/Xq1dPmzZvVvXt3m0/NTJ8+XeHh4YqMjHRApQAAAACQ/dSp+aQmjJ4sSbp2/aoWLPlI7bq+oO9WblDhR0K06qsVmrdwjo6fOKZbMbeUlJgoP18/6/a/Hj6gTu1evucxZn00QzG3b+n7VZtVNKRosv6qlarJZDJZlytVq6GFsz5UUlKSjv7+m1xdXVWhanVrf648eVW0+KM6+nu0tc3L29saaEhS/oKBunzxvCQp5tYtnTz+p0b066lRb0ZY10lMTFRAQEAa36nMx+OnAAAAsqCRI0fKMAyb1+bNmyVJkZGRyfoINAAAAADAfry9vFWsaDEVK1pMlStU0QfjpynmdoyWfLpIe/btVs/+3dXwqWe0dN5n2rh6q/q+/qbiE+Kt23t6et73GDUfr6WkJItWf7Myw87D1dX2jn6TyWSdlyPm1k1J0qhJM/Tzzz9bXwcPHtTOnTszrKaHxZ0aAAAAAAAAAADcg8lkktls1u2429qzb5cKPVJY/SIGWPv/Pn3SZv2ypR7T1h+3qv3zHVPdZ+WKVdS1U3e16/q8XFxcFdG9t03/vv1RNsv7o3YrpFgJubi4qPijpZWYmKhfonZbHz919fIlHT/6u4qXKp2mc8pXoKAKBAbp5F/HVaJElzRtkxUQagAAAAAAAAAA8C/x8fE6d+GcJOnatauav3iebt26qbD6jXXj5g2dOv23Vq75QpUqVNH6Td/pm++/stl+QJ/BatOppYqGFNVzzdooMSlR6zevU5/X+tqsV71qDS2bv1ztu74gV1cXvdbldWvf36f/1vCxQxXevot+ObhfSz+apUGj3pUkFSlWQvUbN9Pbb0bo7fenycfXTx+MGa4CgcGq37h5ms8zYtBwjf/PmyoZnFeNGzdWXFyc9u7dqytXrqh///7pfPcyFqEGAAAAAAAAACBTuHz41f1XSgOTmyEjwXT/FdNp49b1Kl+zlCTJ19dPJYuV1EfTI1Wn5pOSpNe6vK4howYqLj5ezzzVSP17DdT7H75r3b5OzSf10fRITZ7+vqbNmSI/Xz/VfLx2iseqWa2Wln30mdp3e1EuZhe9Ev6aJOnF59opNjZWYc81kIuLWZ1ejdALL3ezbjdm6ly9+58BiujYRgkJ8apa8wnN/mSV3NzcUjxOSp7v2EWeXl5aMOdDDRw4UD4+Pipfvrz69u37oG9ZpiHUAAAAAAAAAADg/017f5amvT/rnuu8/dZovf3WaJu2f99lIUnNwlqoWViLFLeP2nrAZrlW9To6fuCUdXnVsq+t/37/nX8mLL/g52GzTUCu3Bo/Y36qNT7XrpOea9fJpq3Bsy306/nbtnW2aadBPTqnup+shlADAABA0okTJ3Tx4kVHl5EtHD582NElAAAAAACyKUINAACQ4504cUKlSpdR7O0YR5cCAAAAAADugVADAADkeBcvXlTs7RiFdpkoz6ASji7H6V07sFmn10xxdBkAAAAAgGyIUAMAAOD/eQaVkE/IY44uw+ndPnvU0SUAAAAAALIps6MLAAAAAAAAAAAASAtCDQAAAAAAAAAA4BQINfDAfH19bV5ubm6qUKGCo8sCAAAAAAAAAGRzzKmBB3bz5k2b5QoVKqhdu3YOqgYAAAAAAAAAkFNwpwYeyu7du3Xo0CF17tzZ0aUAAAAAAAAAALI5Qg08lPnz56tJkyYKDg52dCkAAAAAAAAAkCV9+t+lKlEpxNFlZLjIyEjlypUrQ4/B46eQbrdu3dKnn36qRYsWOboUAAAAAAAAAE7gy2E/ZurxWo6pna7t9uzbreZtG6t+3YZaNn/5A21btW55vdqlp17r8vr/6mjWWg2eapSuWh5E51aNVKpcBQ0ZM9GmfeWni/XesIHa+cfZDK8ho3GnBtLt888/l7e3t5o2beroUgAAAAAAAADAbpZ9vlivvPyqduz5UWfPnXno/Xl5eil/vvx2qAyEGki3jz76SOHh4XJ15YYfAAAAAAAAANnDzVs3terrlercoZueeaqRPv1iWbJ1vtvwrRq1elqFyxRU6WrFFN6jgySp1UtNdfLUSQ0fM1QFiudSgeK5JKX8+KkFS+fr8acr6ZHS+VWrYTUtX/mpTX+B4rm05LNFCu/RQUUeC1KTGuW0ce1XdjvPjd+u0fMNaqly4VwqVqyYRo0apcTERGv/5MmTVb58efn4+Khw4cJ6/fXXdfPmTZt9REZGqnjx4vLx8dFzzz2nS5cu2a2+1BBqIF2io6P1448/qlu3bo4uBQAAAAAAAADsZvU3K1WyWEmVKFZSz7d6Ucs+XyLDMKz96zZ9p849O6rBU89ow5qt+u/iL1WlYlVJ0oKZSxQc+IgG9x2qAzujdWBndIrH+Pq7NRr2zlvq2a2Xtn67Qy+376w3Bkdo246tNutNnPqeWj77nDZ9vV11G4ZpcM8uunrl8kOfY9TObRrS6xV17B6h1T/8pDlz5igyMlJjx461rmM2mzV16lT9+uuvWrhwoTZu3KhBgwZZ+3ft2qVXXnlFPXv21E8//aSnn35aY8aMeeja7oeP2CNd5s+fryeffFIlS5Z0dCkAAAAAAAAAYDdLly/R8y1flCTVr9tQN25G6Mdd21Sn5pOSpA9mTFKrZm00uO9Q6zblypSXJOXOlVsuLmb5+vqqYP6CqR5j5kfT1a71S+ra8RVJUs9uvRT1817N/Gi6nqhV17peuzbt1brF85KkN4aO1pJ5M3Xgp716sn7q83N8umCuvlgSadOWlJQoDw/P/x3//XF6pc8AtWrXUZJUNn8ZvfPOOxo0aJDefvttSVLfvn2t6xctWlRjxoxRjx49NHPmTEnShx9+qMaNG2vAgAFydXVVqVKl9OOPP2rt2rWp1mYPhBpIlwkTJji6BAAAAAAAAACwqz/+PKKffolS5KwlkiRXV1e1bNpaSz9fbA01fj18QJ3avfxQxzlyNFqd2oXbtFWvUkNzF862aStbupz1394+PvL189flCxfuue9mbdrp1b6DbdrWf71K8z5837ocfeiAftqzQ3M+eE+SZDZJSUlJio2NVUxMjLy9vbV+/XqNHz9ev/32m65fv67ExESb/sOHD6tVq1Y2x6lVqxahBgAAAAAAAAAAmWHp8sVKTExUhdqlrW2GYcjD3UPXR16Tv1+APD0977EH+7p7PmOTySSLYbnnNr7+/ipSrLhNW578BWyWY27dVMTAYWrYtJUkqWReD2ufp6enjh8/rmbNmqlnz54aO3as8uTJo23btqlbt26Kj4+Xt7f3Q5zVwyHUAAAAAAAAAADkeImJiVq+8lONGjpGTz1R36YvvEcHrVjzhTq/1FVlSz2mrT9uVfvnO6a4Hzc3dyUlJd3zWCWLl9KeqF1q1+Yla9vufbtUqkTpe2xlP2XKV9Lxo0es4UeJ/LZBTVRUlCwWiyZNmiSz+Z+puZcvX267jzJltHv3bpu2nTt3ZmDV/yDUAAAAAAAAAADkeN9vXKtr16+qw4ud5O8XYNPXrHELLVu+WJ1f6qoBfQarTaeWKhpSVM81a6PEpESt37xOfV7rK0kqXChEO/f8qOeatZG7u4fy5smb7FgR3Xure58uKvdYBdWr/ZS+2/itvv5ujf67aFUmnKnU882hiujYWkGPFFaj5s/JdNFL+/fv18GDBzVmzBiVKFFCCQkJmjZtmpo3b67t27dr9mzbR2P16dNHderU0eTJk/Xcc8/p+++/z/BHT0mEGgAAAAAAAACATNJyTG277MfkZshIMNllX3cs+3yx6tZ+KlmgIf0Takyf+6F+/e2g6tR8Uh9Nj9Tk6e9r2pwp8vP1U83H/3deg/sO1YBhfVX96cqKi4/T+aNXk+3v2UbNNGb4u5r50TQNe+cthRQqog/fm2GdtyOjPVH/Gc1YskKzJo3T/OmT5O7mptKlS+uVV/6ZuLxixYqaPHmy3nvvPQ0ZMkR169bV+PHj9fLL/5tLpGbNmpo7d65GjhypUaNGqWHDhho2bJjeeeedDK2dUCOLOnHihC5evOjoMrKFw4cPO7oEAAAAAAAAAFncknmfpdpXpWJVm3CiWVgLNQtrkeK61So/rs1fb7dpa/d8B7V7voNNW5cO3dSlQ7dUj5lSGLLzj7Opri9Jkau+T7H9uXad9Fy7TjZtT9R/Rk/Uf0aSVDZ/8nlC+vXrp379+tm0depku4+uXbvq5Zdflqurq0ymf0KmN9988541PixCjSzoxIkTKlW6jGJvxzi6FAAAAAAAAAAAsgxCjSzo4sWLir0do9AuE+UZVMLR5Ti9awc26/SaKY4uAwAAAAAAAADwkAg1sjDPoBLyCXnM0WU4vdtnjzq6BAAAAAAAAACAHZgdXQAAAAAAAAAAAEBaEGoAAAAAAAAAAACnQKgBAAAAAAAAAACcAqEGAAAAAAAAAABwCoQaAAAAAAAAAADAKRBqAAAAAAAAAAAAp0CoAQAAAAAAAAAAnIKrowsAAAAAAAAAAOQMz667kKnH++aZ/A+0fu+BPfXZik8kSa6ursoVkFtlSz+m1s3bqF2bDjKb036fwKf/XaphY4boj59PPFANKWn1UlP9uGu7JMndw0OFioTqpa491L7raw+9b2dDqAEAAAAADlTgk2+UK1cuR5eRo1ksFpnOn1eBAgUe6A8VeDCvpGEdi8Wi84xFlsBYZB2MRdbBWDyY2NhYHTt2THkK+8nT0/NfPZkbauQvFvBA63v6uatx48ZasGCBkpKSdO7cOa1du1bDxgzRd1u+0erVq+XqmrY/q/sV8JbJbHrgGlLi5umq7t27a/To0YqJidGiRYs06q2+KhtSQO3bt0+2fnx8vNzd3R/6uFkRVx8AAAAAAAAAAP/Pw8NDgYGBeuSRR1SlShUNHTpUX375pb799ltFRkZa15s8ebLKly8vHx8fFS5cWK+//rpu3rwpSdq8ebO6dOmia9euyWQyyWQyaeTIkZKkxYsXq1q1avLz81NgYKBeeuklnT9//r51eXt7KzAwUMWKFdPIkSNVsmRJrV69WpL01FNPqVevXurbt6/y5cunsLAwSdLBgwfVpEkT+fr6qmDBgurUqZMuXrxo3eed7Xr16qWAgADly5dPw4cPl2EYdno37Y9QAwAAAAAAAACAe6hfv74qVqyoFStWWNvMZrOmTp2qX3/9VQsXLtTGjRs1aNAgSVLt2rU1ZcoU+fv768yZMzpz5owGDBggSUpISNA777yj/fv3a9WqVTp+/Lg6d+78wDV5eXkpPj7eurxw4UK5u7tr+/btmj17tq5evar69eurcuXK2rt3r9auXatz587pxRdftNnPwoUL5erqqt27d+vDDz/U5MmT9dFHH6XjXcocPH4KAAAAAAAAAID7KF26tH755Rfrct++fa3/Llq0qMaMGaMePXpo5syZcnd3V0BAgEwmkwIDA23207VrV+u/ixUrpqlTp+rxxx/XzZs35evre986kpKS9Mknn+iXX37Rq6++am0vWbKkJkyYYF0eM2aMKleurHHjxlnbPv74YxUuXFi///67Hn30UUlS4cKF9cEHH8hkMqlUqVI6cOCAPvjgA3Xv3j3tb04m4k4NAAAAAAAAAADuwzAMmUwm6/L69evVoEEDPfLII/Lz81OnTp106dIlxcTE3HM/UVFRat68uUJCQuTn56d69epJkk6cuPeE4jNnzpSvr6+8vLzUvXt39evXTz179rT2V61a1Wb9/fv3a9OmTfL19bW+SpcuLUk6evSodb2aNWvanFetWrV05MgRJSUl3ecdcQzu1AAAAAAAAAAA4D4OHz6s0NBQSdLx48fVrFkz9ezZU2PHjlWePHm0bds2devWTfHx8fL29k5xH7du3VJYWJjCwsK0dOlS5c+fXydOnFBYWJjNo6RS0qFDB/3nP/+Rl5eXgoKCkk1Y7+PjY7N88+ZNNW/eXO+9916yfQUFBT3IqWcphBoAAAAAAAAAANzDxo0bdeDAAfXr10/SP3dbWCwWTZo0yRouLF++3GYbd3f3ZHc7/Pbbb7p06ZLeffddFS5cWJK0d+/eNNUQEBCgEiVKpLnmKlWq6IsvvlDRokXl6pp6FLBr1y6b5Z07d6pkyZJycXFJ87EyE4+fAgAAAAAAAADg/8XFxens2bM6deqU9u3bp3Hjxqlly5Zq1qyZXn75ZUlSiRIllJCQoGnTpunPP//U4sWLNXv2bJv9FC1aVDdv3tSGDRt08eJFxcTEKCQkRO7u7tbtVq9erXfeeSdDziMiIkKXL19W+/bttWfPHh09elTfffedunTpYhO2nDhxQv3791d0dLQ++eQTTZs2TW+88UaG1GQP3KkBAAAAAAAAAMgUe15L+50GqTEMQ4mJiXJ1dbWZC8Je1q5dq6CgILm6uip37tyqWLGipk6dqvDwcOtdGRUrVtTkyZP13nvvaciQIapbt67Gjx9vDT0kqXbt2urRo4fatm2rS5cu6e2339bIkSMVGRmpoUOHaurUqapSpYomTpyoFi1a2P08goODtX37dg0ePFiNGjVSXFycihQposaNG9s8uurll1/W7du3Vb16dbm4uOiNN96wmYA8qyHUAAAAAAAAAABAUmRkpCIjI9O0br9+/ayPo7qjU6dONsuzZs3SrFmzbNrat2+v9u3b27QZhnHPY23evDld/SVLltSKFSvuua2bm5umTJmSrM6sisdPAQAAAAAAAAAAp0CoAQAAAAAAAAAAnAKPnwIAAAAAAAAAIAe632OtsiLu1AAAAAAAAAAAAE6BUAMAAAAAAAAAkCHuNwE2chZ7/H8g1AAAAAAAAAAA2JWbm5skKSYmxsGVICu58//hzv+P9GBODQAAAAAAAACAXbm4uChXrlw6f/68JMnb21smk8ku+zYMQ4mJiXJ1dbXbPpE+aR0LwzAUExOj8+fPK1euXHJxcUn3MQk1AAAAAAAAAAB2FxgYKEnWYMNeDMOQxWKR2Wwm1HCwBx2LXLlyWf9fpBehBgAAAAAAAADA7kwmk4KCglSgQAElJCTYbb8Wi0WXLl1S3rx5ZTYzw4IjPchYuLm5PdQdGncQagAAAAAAAAAAMoyLi4td/ph9h8VikZubmzw9PQk1HMwRY5FtR3zGjBkqWrSoPD09VaNGDe3evdvRJQEAAAAAAAAAgIeQLUONzz77TP3799fbb7+tffv2qWLFigoLC7P7s9sAAAAAAAAAAEDmyZahxuTJk9W9e3d16dJFZcuW1ezZs+Xt7a2PP/7Y0aUBAAAAAAAAAIB0ynZzasTHxysqKkpDhgyxtpnNZjVs2FA7duxIcZu4uDjFxcVZl69duyZJunr1qiwWS8YWnIIbN27IZDIp9sRBGXExmX787Cb+zFGZTCb9cv2WbiYZji7H6f15K0Ymk0k3btzQ1atXHV1OlsP1a19cv/bDtXtvXLv2xbVrX1nh+r1+/bokyTAYT3u6835ev36dZ0E7mMVi0Y0bN3gudxbAWGQdjEXWwVhkHYxF1sFYZB32HIu0/t5hMrLZbyanT5/WI488oh9//FG1atWytg8aNEhbtmzRrl27km0zcuRIjRo1KjPLBAAAAJzOyZMnVahQIUeXkW38+eefKl68uKPLAAAAALKU+/3eke3u1EiPIUOGqH///tZli8Wiy5cvK2/evDKZTA6sDPZw/fp1FS5cWCdPnpS/v7+jywHwALh+AefEtZv9GIahGzduKDg42NGlZCt58uSRJJ04cUIBAQEOriZn4+tW1sFYZB2MRdbBWGQdjEXWwVhkHfYci7T+3pHtQo18+fLJxcVF586ds2k/d+6cAgMDU9zGw8NDHh4eNm25cuXKqBLhIP7+/nyRA5wU1y/gnLh2sxf+6G5/d27PDwgI4FrJIvi6lXUwFlkHY5F1MBZZB2ORdTAWWYe9xiItv3dkuweOubu7q2rVqtqwYYO1zWKxaMOGDTaPowIAAAAAAAAAAM4l292pIUn9+/dXeHi4qlWrpurVq2vKlCm6deuWunTp4ujSAAAAAAAAAABAOmXLUKNt27a6cOGCRowYobNnz6pSpUpau3atChYs6OjS4AAeHh56++23kz1iDEDWx/ULOCeuXSBtuFayDsYi62Assg7GIutgLLIOxiLrYCyyDkeMhckwDCPTjgYAAAAAAAAAAJBO2W5ODQAAAAAAAAAAkD0RagAAAAAAAAAAAKdAqAEAAAAAAAAAAJwCoQYAwKGKFi2qKVOmpNr/1FNPqW/fvplWD5CTRUZGKleuXI4uI8PllPMEAAAAgOyIUANOqXPnzjKZTMlejRs31uXLl9W7d2+VKlVKXl5eCgkJUZ8+fXTt2jXr9sePH09xe5PJpJ07dzrwzICs5e5rLW/evGrcuLF++eUXR5cGQNKOHTvk4uKipk2bPvC2KQWKbdu21e+//26n6lKXWlhJ2ICcZsaMGSpatKg8PT1Vo0YN7d6929ElZWvjx4/X448/Lj8/PxUoUECtWrVSdHS0zTqxsbGKiIhQ3rx55evrqzZt2ujcuXMOqjjnePfdd2UymWy+NzAWmefUqVPq2LGj8ubNKy8vL5UvX1579+619huGoREjRigoKEheXl5q2LChjhw54sCKs6ekpCQNHz5coaGh8vLyUvHixfXOO+/IMAzrOoxFxtm6dauaN2+u4OBgmUwmrVq1yqY/Le/95cuX1aFDB/n7+ytXrlzq1q2bbt68mYlnkT3caywSEhI0ePBglS9fXj4+PgoODtbLL7+s06dP2+yDsbCP+10X/9ajRw+ZTKZkv2Nm1FgQasBpNW7cWGfOnLF5ffLJJzp9+rROnz6tiRMn6uDBg4qMjNTatWvVrVu3ZPtYv359sn1UrVrVAWcDZF3/vtY2bNggV1dXNWvWzNFlAZA0f/589e7dW1u3bk32g3x6eHl5qUCBAnaoDMD9fPbZZ+rfv7/efvtt7du3TxUrVlRYWJjOnz/v6NKyrS1btigiIkI7d+7UunXrlJCQoEaNGunWrVvWdfr166c1a9bo888/15YtW3T69Gm1bt3agVVnf3v27NGcOXNUoUIFm3bGInNcuXJFderUkZubm7799lsdOnRIkyZNUu7cua3rTJgwQVOnTtXs2bO1a9cu+fj4KCwsTLGxsQ6sPPt57733NGvWLE2fPl2HDx/We++9pwkTJmjatGnWdRiLjHPr1i1VrFhRM2bMSLE/Le99hw4d9Ouvv2rdunX66quvtHXrVr366quZdQrZxr3GIiYmRvv27dPw4cO1b98+rVixQtHR0WrRooXNeoyFfdzvurhj5cqV2rlzp4KDg5P1ZdhYGIATCg8PN1q2bJnm9ZcvX264u7sbCQkJhmEYxrFjxwxJxk8//ZQxBQLZRErX2g8//GBIMs6fP28YhmEMGjTIKFmypOHl5WWEhoYaw4YNM+Lj4222Wb16tVGtWjXDw8PDyJs3r9GqVStrX5EiRYwPPvjAujxv3jwjICDAWL9+vWEYhlGvXj0jIiLCiIiIMPz9/Y28efMaw4YNMywWi3Wby5cvG506dTJy5cpleHl5GY0bNzZ+//13a/+CBQuMgIAAY+3atUbp0qUNHx8fIywszDh9+rRNnfPmzTNKly5teHh4GKVKlTJmzJjxUO8fkJFu3Lhh+Pr6Gr/99pvRtm1bY+zYscnWSe3aq1evniHJ5mUY/7tW/m3mzJlGsWLFDDc3N+PRRx81Fi1aZNMvyZg3b57RqlUrw8vLyyhRooTx5Zdf3rP2evXqGW+88Uay9pSOv2rVKqNy5cqGh4eHERoaaowcOdL6/dwwDGPSpElGuXLlDG9vb6NQoUJGz549jRs3biTbb+HChQ0vLy+jVatWxsSJE5MdB8hs1atXNyIiIqzLSUlJRnBwsDF+/HgHVpWznD9/3pBkbNmyxTAMw7h69arh5uZmfP7559Z1Dh8+bEgyduzY4agys7UbN24YJUuWNNatW2fzvYGxyDyDBw82nnjiiVT7LRaLERgYaLz//vvWtqtXrxoeHh7GJ598khkl5hhNmzY1unbtatPWunVro0OHDoZhMBaZSZKxcuVK63Ja3vtDhw4Zkow9e/ZY1/n2228Nk8lknDp1KtNqz27uHouU7N6925Bk/PXXX4ZhMBYZJbWx+Pvvv41HHnnEOHjwYLK/72TkWHCnBnKEa9euyd/fX66uro4uBXBqN2/e1JIlS1SiRAnlzZtXkuTn56fIyEgdOnRIH374oebNm6cPPvjAus3XX3+t5557Ts8++6x++uknbdiwQdWrV09x/xMmTNBbb72l77//Xg0aNLC2L1y4UK6urtq9e7c+/PBDTZ48WR999JG1v3Pnztq7d69Wr16tHTt2yDAMPfvss0pISLCuExMTo4kTJ2rx4sXaunWrTpw4oQEDBlj7ly5dqhEjRmjs2LE6fPiwxo0bp+HDh2vhwoV2e/8Ae1q+fLlKly6tUqVKqWPHjvr4449tHk9wr2tvxYoVKlSokEaPHm29EyslK1eu1BtvvKE333xTBw8e1GuvvaYuXbpo06ZNNuuNGjVKL774on755Rc9++yz6tChgy5fvvzQ5/jDDz/o5Zdf1htvvKFDhw5pzpw5ioyM1NixY63rmM1mTZ06Vb/++qsWLlyojRs3atCgQdb+Xbt2qVu3burVq5d+/vlnPf300xozZsxD1wY8jPj4eEVFRalhw4bWNrPZrIYNG2rHjh0OrCxnufN42jx58kiSoqKilJCQYDMupUuXVkhICOOSQSIiItS0aVOb91xiLDLT6tWrVa1aNb3wwgsqUKCAKleurHnz5ln7jx07prNnz9qMRUBAgGrUqMFY2Fnt2rW1YcMG66NA9+/fr23btqlJkyaSGAtHSst7v2PHDuXKlUvVqlWzrtOwYUOZzWbt2rUr02vOSa5duyaTyWR9jC1jkXksFos6deqkgQMH6rHHHkvWn6Fj8VCRCOAg4eHhhouLi+Hj42PzSulTqhcuXDBCQkKMoUOHWtvu3Knh5eWVbB8A/ufua02SERQUZERFRaW6zfvvv29UrVrVulyrVi3rp4tScifJHzRokBEUFGQcPHjQpr9evXpGmTJlbO7MGDx4sFGmTBnDMAzj999/NyQZ27dvt/ZfvHjR8PLyMpYvX24Yxj+f0pZk/PHHH9Z1ZsyYYRQsWNC6XLx4cWPZsmU2x37nnXeMWrVqpVo74Ei1a9c2pkyZYhiGYSQkJBj58uUzNm3aZO1P67X3b3ffKVG7dm2je/fuNuu88MILxrPPPmtdlmQMGzbMunzz5k1DkvHtt9+meux69eoZbm5uyb4He3h42By/QYMGxrhx42y2Xbx4sREUFJTqvj///HMjb9681uX27dvb1GsYhtG2bVvu1IBDnTp1ypBk/PjjjzbtAwcONKpXr+6gqnKWpKQko2nTpkadOnWsbUuXLjXc3d2Trfv4448bgwYNyszycoRPPvnEKFeunHH79m3DMGzv4mMsMo+Hh4fh4eFhDBkyxNi3b58xZ84cw9PT04iMjDQMwzC2b99uSEp2h/MLL7xgvPjii44oOdtKSkoyBg8ebJhMJsPV1dUwmUw2PwcxFplHd30iPS3v/dixY41HH3002b7y589vzJw5M0Przc7uHou73b5926hSpYrx0ksvWdsYi4yR0liMGzfOeOaZZ6x/r7n7d8yMHAs+tg6n9fTTT2vWrFk2bXc+ZXXH9evX1bRpU5UtW1YjR45Mto/PPvtMZcqUycgyAaf372vtypUrmjlzppo0aaLdu3erSJEi+uyzzzR16lQdPXpUN2/eVGJiovz9/a3b//zzz+revfs9jzFp0iTdunVLe/fuVbFixZL116xZUyaTybpcq1YtTZo0SUlJSTp8+LBcXV1Vo0YNa3/evHlVqlQpHT582Nrm7e2t4sWLW5eDgoKszy2/deuWjh49qm7dutnUmpiYqICAgLS+VUCmiY6O1u7du7Vy5UpJkqurq9q2bav58+frqaeekpS2a+9+Dh8+nOx5p3Xq1NGHH35o0/bv56D7+PjI39//vvMCdOjQQf/5z39s2lasWKFx48ZZl/fv36/t27fb3JmRlJSk2NhYxcTEyNvbW+vXr9f48eP122+/6fr160pMTLTpP3z4sJ577jmb49SqVUtr165N25sAIFuKiIjQwYMHtW3bNkeXkiOdPHlSb7zxhtatWydPT09Hl5OjWSwWVatWzfr9t3Llyjp48KBmz56t8PBwB1eXsyxfvlxLly7VsmXL9Nhjj+nnn39W3759FRwczFgAKUhISNCLL74owzCS/X0QGS8qKkoffvih9u3bZ/P3msxCqAGn5ePjoxIlSqTaf+PGDTVu3Fh+fn5auXKl3Nzckq1TuHDhe+4DQPJr7aOPPlJAQIDmzZunpk2bqkOHDho1apTCwsIUEBCgTz/9VJMmTbKu7+Xldd9jPPnkk/r666+1fPlyvfXWWxlyHnd/DTCZTNZH9dy8eVOSNG/ePJtwRJJcXFwypB7gYcyfP1+JiYk2E7EZhiEPDw9Nnz5dAQEBabr27CWl68tisdxzm4CAgGTfg++epPzmzZsaNWpUihPDenp66vjx42rWrJl69uypsWPHKk+ePNq2bZu6deum+Ph4eXt7p/OMgIyVL18+ubi46Ny5czbt586dU2BgoIOqyjl69eplnaiyUKFC1vbAwEDFx8fr6tWr1kdYSIxLRoiKitL58+dVpUoVa1tSUpK2bt2q6dOn67vvvmMsMklQUJDKli1r01amTBl98cUXkmR9v8+dO6egoCDrOufOnVOlSpUyrc6cYODAgXrrrbfUrl07SVL58uX1119/afz48QoPD2csHCgt731gYGCyD/UkJibq8uXLfN3KAHcCjb/++ksbN260+WAlY5E5fvjhB50/f14hISHWtqSkJL355puaMmWKjh8/nqFjwZwayJauX7+uRo0ayd3dXatXr+bTP4AdmUwmmc1m3b59Wz/++KOKFCmi//znP6pWrZpKliypv/76y2b9ChUqaMOGDffcZ/Xq1fXtt99q3LhxmjhxYrL+u5+1uHPnTpUsWVIuLi4qU6aMEhMTbda5dOmSoqOjk/2ClpqCBQsqODhYf/75p0qUKGHzCg0NTdM+gMySmJioRYsWadKkSfr555+tr/379ys4OFiffPKJpPtfe+7u7kpKSrrnscqUKaPt27fbtG3fvj3N19bDqlKliqKjo5NdlyVKlJDZbFZUVJQsFosmTZqkmjVr6tFHH9Xp06eTnUNKX0MAR3J3d1fVqlVtrlGLxaINGzaoVq1aDqwsezMMQ7169dLKlSu1cePGZN/jq1atKjc3N5txiY6O1okTJxgXO2vQoIEOHDhg832sWrVq6tChg/XfjEXmqFOnjqKjo23afv/9dxUpUkSSFBoaqsDAQJuxuH79unbt2sVY2FlMTIzMZts/07m4uFg/KMJYOE5a3vtatWrp6tWrioqKsq6zceNGWSyWZB+cw8O5E2gcOXJE69evt873eQdjkTk6deqkX375xeZ7eXBwsAYOHKjvvvtOUsaOBXdqwGnFxcXp7NmzNm2urq5yd3dXo0aNFBMToyVLluj69eu6fv26JCl//vw2n7q+dOlSsn3kypWLEAT4l39fa1euXNH06dN18+ZNNW/eXNevX9eJEyf06aef6vHHH9fXX39tfRzOHW+//bYaNGig4sWLq127dkpMTNQ333yjwYMH26xXu3ZtffPNN2rSpIlcXV3Vt29fa9+JEyfUv39/vfbaa9q3b5+mTZtmvRukZMmSatmypbp37645c+bIz89Pb731lh555BG1bNkyzec5atQo9enTRwEBAWrcuLHi4uK0d+9eXblyRf3790/nuwfY31dffaUrV66oW7duyR6P1qZNG82fP189evS477VXtGhRbd26Ve3atZOHh4fy5cuX7FgDBw7Uiy++qMqVK6thw4Zas2aNVqxYofXr12fKuY4YMULNmjVTSEiInn/+eZnNZu3fv18HDx7UmDFjVKJECSUkJGjatGlq3ry5tm/frtmzZ9vso0+fPqpTp44mTpyoli1b6rvvvuPRU8gS+vfvr/DwcFWrVk3Vq1fXlClTdOvWLXXp0sXRpWVbERERWrZsmb788kv5+flZf765c3dbQECAunXrpv79+ytPnjzy9/dX7969VatWLdWsWdPB1Wcvfn5+KleunE2bj4+P8ubNa21nLDJHv379VLt2bY0bN04vvviidu/erblz52ru3LmS/vlAU9++fTVmzBiVLFlSoaGhGj58uIKDg9WqVSvHFp/NNG/eXGPHjlVISIgee+wx/fTTT5o8ebK6du0qibHIaDdv3tQff/xhXT527Jh+/vln5cmTRyEhIfd978uUKaPGjRure/fumj17thISEtSrVy+1a9fO5u5q3N+9xiIoKEjPP/+89u3bp6+++kpJSUnW7+d58uSRu7s7Y2FH97su7g6U3NzcFBgYqFKlSknK4OvioWbkABwkPDzckJTsVapUKWPTpk0p9kkyjh07ZhjG/yYKT+n1ySefOPbkgCzk7mvNz8/PePzxx43//ve/1nUGDhxo5M2b1/D19TXatm1rfPDBB8km4P3iiy+MSpUqGe7u7ka+fPmM1q1bW/vunkhqy5Ytho+PjzF16lTDMP6ZNPL11183evToYfj7+xu5c+c2hg4dajNx+OXLl41OnToZAQEBhpeXlxEWFmb8/vvv1v67Jz82DMNYuXKlcfe3waVLl1rrzJ07t1G3bl1jxYoV6X37gAzRrFmzZBNf37Fr1y5DkrF//37DMO597e3YscOoUKGC4eHhYb0WUrpWZs6caRQrVsxwc3MzHn30UWPRokU2/UphwriAgABjwYIFqZ7DvyeD/beUjr927Vqjdu3ahpeXl+Hv729Ur17dmDt3rrV/8uTJRlBQkPXaX7RokSHJuHLlinWd+fPnG4UKFTK8vLyM5s2bGxMnTmSicGQJ06ZNM0JCQgx3d3ejevXqxs6dOx1dUraW2s////56dfv2beP11183cufObXh7exvPPfeccebMGccVnYPc/b2Bscg8a9asMcqVK2d4eHgYpUuXtvk+axiGYbFYjOHDhxsFCxY0PDw8jAYNGhjR0dEOqjb7un79uvHGG28YISEhhqenp1GsWDHjP//5jxEXF2ddh7HIOKn9LSk8PNwwjLS995cuXTLat29v+Pr6Gv7+/kaXLl2MGzduOOBsnNu9xuJef8/btGmTdR+MhX3c77q4291/3zGMjBsLk2H8/wPFAQAAAAAAAAAAsjDm1AAAAAAAAAAAAE6BUAMAAAAAAAAAADgFQg0AAAAAAAAAAOAUCDUAAAAAAAAAAIBTINQAAAAAAAAAAABOgVADAAAAAAAAAAA4BUINAAAAAAAAAADgFAg1AAAAAAAAAACAUyDUAAAAAAAAgMN17txZRYsWdXQZySxfvlx58uTRzZs3M+2YCQkJKly4sGbOnJlpxwQAZ0GoAQAAAAAAgAxhMpnS9Nq8ebOjS01RUlKS3n77bfXu3Vu+vr6Zdlw3Nzf1799fY8eOVWxsbKYdFwCcgckwDMPRRQAAAAAAACD7WbJkic3yokWLtG7dOi1evNim/ZlnnlGePHlksVjk4eGRmSXe06pVq9S6dWudPHlSjzzySKYe++rVqypYsKBmzZqlrl27ZuqxASArI9QAAAAAAABApujVq5dmzJghZ/lzVMuWLXX58mX98MMPDjl+8+bNde3aNW3dutUhxweArIjHTwEAAAAAAMDh7p5T4/jx4zKZTJo4caJmzJihYsWKydvbW40aNdLJkydlGIbeeecdFSpUSF5eXtYA4m7ffvutnnzySfn4+MjPz09NmzbVr7/+et96YmNjtXbtWjVs2DBZn8lkUq9evfT555+rbNmy8vLyUq1atXTgwAFJ0pw5c1SiRAl5enrqqaee0vHjx222P3LkiNq0aaPAwEB5enqqUKFCateuna5du2az3jPPPKNt27aleF4AkFO5OroAAAAAAAAAIDVLly5VfHy8evfurcuXL2vChAl68cUXVb9+fW3evFmDBw/WH3/8oWnTpmnAgAH6+OOPrdsuXrxY4eHhCgsL03vvvaeYmBjNmjVLTzzxhH766ad7TkweFRWl+Ph4ValSJcX+H374QatXr1ZERIQkafz48WrWrJkGDRqkmTNn6vXXX9eVK1c0YcIEde3aVRs3bpQkxcfHKywsTHFxcerdu7cCAwN16tQpffXVV7p69aoCAgKsx6hataoMw9CPP/6oZs2a2eHdBADnR6gBAAAAAACALOvUqVM6cuSI9Y/9SUlJGj9+vG7fvq29e/fK1fWfP29duHBBS5cu1axZs+Th4aGbN2+qT58+euWVVzR37lzr/sLDw1WqVCmNGzfOpv1uv/32myQpNDQ0xf7o6Gj99ttv1mAkd+7ceu211zRmzBj9/vvv8vPzs6n3+PHjKlq0qA4dOqRjx47p888/1/PPP2/d34gRI5Ido1ixYpKkQ4cOEWoAwP/j8VMAAAAAAADIsl544QWbuxdq1KghSerYsaM10LjTHh8fr1OnTkmS1q1bp6tXr6p9+/a6ePGi9eXi4qIaNWpo06ZN9zzupUuXJP0TVqSkQYMGNnd63KmrTZs21kDj3+1//vmnJFnP5bvvvlNMTMw9a7hz7IsXL95zPQDISbhTAwAAAAAAAFlWSEiIzfKdUKBw4cIptl+5ckXSP/NWSFL9+vVT3K+/v3+ajp/apObprSs0NFT9+/fX5MmTtXTpUj355JNq0aKFOnbsaBPe/PvYJpMpTbUCQE5AqAEAAAAAAIAsy8XF5YHa7wQBFotF0j/zagQGBiZb7993eaQkb968kv4JIwoVKmS3uiRp0qRJ6ty5s7788kt9//336tOnj8aPH6+dO3faHOtOEJIvX7571goAOQmhBgAAAAAAALKd4sWLS5IKFCighg0bPvD2pUuXliQdO3ZM5cuXt2ttklS+fHmVL19ew4YN048//qg6depo9uzZGjNmjHWdY8eOSZLKlClj9+MDgLNiTg0AAAAAAABkO2FhYfL399e4ceOUkJCQrP/ChQv33L5q1apyd3fX3r177VrX9evXlZiYaNNWvnx5mc1mxcXF2bRHRUXJZDKpVq1adq0BAJwZd2oAAAAAAAAg2/H399esWbPUqVMnValSRe3atVP+/Pl14sQJff3116pTp46mT5+e6vaenp5q1KiR1q9fr9GjR9utro0bN6pXr1564YUX9OijjyoxMVGLFy+Wi4uL2rRpY7PuunXrVKdOHeujsAAAhBoAAAAAAADIpl566SUFBwfr3Xff1fvvv6+4uDg98sgjevLJJ9WlS5f7bt+1a1e1adNGJ0+eTDYBeHpVrFhRYWFhWrNmjU6dOiVvb29VrFhR3377rWrWrGld79q1a/r+++81c+ZMuxwXALILk/HvWYoAAAAAAAAASJKSkpJUtmxZvfjii3rnnXcy9dhTpkzRhAkTdPToUXl5eWXqsQEgK2NODQAAAAAAACAFLi4uGj16tGbMmKGbN29m2nETEhI0efJkDRs2jEADAO7CnRoAAAAAAAAAAMApcKcGAAAAAAAAAABwCoQaAAAAAAAAAADAKRBqAAAAAAAAAAAAp0CoAQAAAAAAAAAAnAKhBgAAAAAAAAAAcAqEGgAAAAAAAAAAwCkQagAAAAAAAAAAAKdAqAEAAAAAAAAAAJwCoQYAAAAAAAAAAHAKhBoAAAAAAAAAAMAp/B+iFOiD9N0MFgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1600x1200 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if TRT_AVAILABLE:\n",
    "    fig, axes = plt.subplots(2, 2, figsize=(16, 12))\n",
    "\n",
    "    # Plot 1: Side-by-side bar chart of inference times\n",
    "    ax1 = axes[0, 0]\n",
    "    components = [\"E2E\", \"Backbone\", \"Action Head\"]\n",
    "    pytorch_times = [\n",
    "        np.mean(timing_results[\"e2e_time\"]) * 1000,\n",
    "        np.mean(timing_results[\"backbone_time\"]) * 1000,\n",
    "        np.mean(timing_results[\"action_head_time\"]) * 1000,\n",
    "    ]\n",
    "    trt_times = [\n",
    "        np.mean(trt_timing_results[\"e2e_time\"]) * 1000,\n",
    "        np.mean(trt_timing_results[\"backbone_time\"]) * 1000,\n",
    "        np.mean(trt_timing_results[\"action_head_time\"]) * 1000,\n",
    "    ]\n",
    "    \n",
    "    x = np.arange(len(components))\n",
    "    width = 0.35\n",
    "    \n",
    "    bars1 = ax1.bar(x - width/2, pytorch_times, width, label='PyTorch', color='#3498db', edgecolor='black')\n",
    "    bars2 = ax1.bar(x + width/2, trt_times, width, label='TensorRT', color='#e74c3c', edgecolor='black')\n",
    "    \n",
    "    ax1.set_ylabel('Time (ms)', fontsize=12)\n",
    "    ax1.set_title('PyTorch vs TensorRT Inference Time', fontsize=14)\n",
    "    ax1.set_xticks(x)\n",
    "    ax1.set_xticklabels(components)\n",
    "    ax1.legend()\n",
    "    ax1.grid(axis='y', alpha=0.3)\n",
    "    \n",
    "    # Add value labels\n",
    "    for bar, val in zip(bars1, pytorch_times):\n",
    "        ax1.annotate(f'{val:.1f}', xy=(bar.get_x() + bar.get_width()/2, bar.get_height()),\n",
    "                    xytext=(0, 3), textcoords=\"offset points\", ha='center', va='bottom', fontsize=9)\n",
    "    for bar, val in zip(bars2, trt_times):\n",
    "        ax1.annotate(f'{val:.1f}', xy=(bar.get_x() + bar.get_width()/2, bar.get_height()),\n",
    "                    xytext=(0, 3), textcoords=\"offset points\", ha='center', va='bottom', fontsize=9)\n",
    "\n",
    "    # Plot 2: Speedup bar chart\n",
    "    ax2 = axes[0, 1]\n",
    "    speedups = [pytorch_times[i] / trt_times[i] if trt_times[i] > 0 else 0 for i in range(len(components))]\n",
    "    colors_speedup = ['#2ecc71' if s > 1 else '#e74c3c' for s in speedups]\n",
    "    \n",
    "    bars3 = ax2.bar(components, speedups, color=colors_speedup, edgecolor='black')\n",
    "    ax2.axhline(y=1, color='black', linestyle='--', linewidth=1, label='No speedup')\n",
    "    ax2.set_ylabel('Speedup (x)', fontsize=12)\n",
    "    ax2.set_title('TensorRT Speedup over PyTorch', fontsize=14)\n",
    "    ax2.grid(axis='y', alpha=0.3)\n",
    "    \n",
    "    for bar, val in zip(bars3, speedups):\n",
    "        ax2.annotate(f'{val:.2f}x', xy=(bar.get_x() + bar.get_width()/2, bar.get_height()),\n",
    "                    xytext=(0, 3), textcoords=\"offset points\", ha='center', va='bottom', fontsize=10, fontweight='bold')\n",
    "\n",
    "    # Plot 3: Max frequency comparison\n",
    "    ax3 = axes[1, 0]\n",
    "    pytorch_freqs = [1000/t if t > 0 else 0 for t in pytorch_times]\n",
    "    trt_freqs = [1000/t if t > 0 else 0 for t in trt_times]\n",
    "    \n",
    "    bars4 = ax3.bar(x - width/2, pytorch_freqs, width, label='PyTorch', color='#3498db', edgecolor='black')\n",
    "    bars5 = ax3.bar(x + width/2, trt_freqs, width, label='TensorRT', color='#e74c3c', edgecolor='black')\n",
    "    \n",
    "    ax3.set_ylabel('Frequency (Hz)', fontsize=12)\n",
    "    ax3.set_title('Maximum Achievable Frequency', fontsize=14)\n",
    "    ax3.set_xticks(x)\n",
    "    ax3.set_xticklabels(components)\n",
    "    ax3.legend()\n",
    "    ax3.grid(axis='y', alpha=0.3)\n",
    "    \n",
    "    for bar, val in zip(bars4, pytorch_freqs):\n",
    "        ax3.annotate(f'{val:.0f}', xy=(bar.get_x() + bar.get_width()/2, bar.get_height()),\n",
    "                    xytext=(0, 3), textcoords=\"offset points\", ha='center', va='bottom', fontsize=9)\n",
    "    for bar, val in zip(bars5, trt_freqs):\n",
    "        ax3.annotate(f'{val:.0f}', xy=(bar.get_x() + bar.get_width()/2, bar.get_height()),\n",
    "                    xytext=(0, 3), textcoords=\"offset points\", ha='center', va='bottom', fontsize=9)\n",
    "\n",
    "    # Plot 4: Time breakdown pie charts\n",
    "    ax4 = axes[1, 1]\n",
    "    \n",
    "    # Create a stacked horizontal bar chart showing time breakdown\n",
    "    breakdown_labels = ['PyTorch', 'TensorRT']\n",
    "    backbone_times = [np.mean(timing_results[\"backbone_time\"])*1000, np.mean(trt_timing_results[\"backbone_time\"])*1000]\n",
    "    action_head_times = [np.mean(timing_results[\"action_head_time\"])*1000, np.mean(trt_timing_results[\"action_head_time\"])*1000]\n",
    "    data_prep_times = [np.mean(timing_results[\"data_prep_time\"])*1000, np.mean(trt_timing_results[\"data_prep_time\"])*1000]\n",
    "    \n",
    "    y_pos = np.arange(len(breakdown_labels))\n",
    "    \n",
    "    ax4.barh(y_pos, backbone_times, height=0.5, label='Backbone', color='#e74c3c')\n",
    "    ax4.barh(y_pos, action_head_times, height=0.5, left=backbone_times, label='Action Head', color='#9b59b6')\n",
    "    ax4.barh(y_pos, data_prep_times, height=0.5, left=[backbone_times[i]+action_head_times[i] for i in range(2)], label='Data Prep', color='#3498db')\n",
    "    \n",
    "    ax4.set_xlabel('Time (ms)', fontsize=12)\n",
    "    ax4.set_title('Inference Time Breakdown', fontsize=14)\n",
    "    ax4.set_yticks(y_pos)\n",
    "    ax4.set_yticklabels(breakdown_labels)\n",
    "    ax4.legend(loc='lower right')\n",
    "    ax4.grid(axis='x', alpha=0.3)\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "else:\n",
    "    print(\"TensorRT visualization not available - engine not found\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final Summary\n",
    "\n",
    "This notebook analyzed the inference timing breakdown for the GR00T model with three backends:\n",
    "\n",
    "### Inference Modes Compared:\n",
    "1. **PyTorch Eager**: Standard PyTorch execution without optimizations\n",
    "2. **torch.compile**: PyTorch 2.0+ JIT compilation with `max-autotune` mode\n",
    "3. **TensorRT**: Optimized DiT action head with TensorRT engine\n",
    "\n",
    "### Key Findings:\n",
    "\n",
    "1. **TensorRT Acceleration**: TensorRT accelerates the DiT (Diffusion Transformer) action head the most, providing the highest speedup for production deployments.\n",
    "\n",
    "2. **torch.compile Benefits**: Provides meaningful speedup over eager mode with zero setup overhead - good for development and quick experiments.\n",
    "\n",
    "3. **Backbone Unchanged**: The backbone (VLM) timing remains similar across all modes as TensorRT only optimizes the DiT.\n",
    "\n",
    "### Deployment Recommendations:\n",
    "\n",
    "- **Use TensorRT** for production deployments where inference speed is critical\n",
    "- **Use torch.compile** for development/prototyping when TensorRT setup is not feasible\n",
    "- **Use PyTorch Eager** for debugging and model development"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "====================================================================================================\n",
      "FINAL COMPREHENSIVE SUMMARY\n",
      "====================================================================================================\n",
      "\n",
      "Hardware: NVIDIA H100 80GB HBM3\n",
      "Model: nvidia/GR00T-N1.7-3B\n",
      "Action Horizon: 50\n",
      "Denoising Steps: 4\n",
      "\n",
      "----------------------------------------------------------------------------------------------------\n",
      "PYTORCH EAGER TIMING RESULTS\n",
      "----------------------------------------------------------------------------------------------------\n",
      "  E2E Inference:  148.62 ms (6.7 Hz)\n",
      "  Backbone Only:  37.96 ms (26.3 Hz)\n",
      "  Action Head:    94.28 ms (10.6 Hz)\n",
      "\n",
      "----------------------------------------------------------------------------------------------------\n",
      "torch.compile TIMING RESULTS (mode='max-autotune')\n",
      "----------------------------------------------------------------------------------------------------\n",
      "  E2E Inference:  69.38 ms (14.4 Hz)\n",
      "  Backbone Only:  36.71 ms (27.2 Hz)\n",
      "  Action Head:    12.56 ms (79.6 Hz)\n",
      "\n",
      "----------------------------------------------------------------------------------------------------\n",
      "TENSORRT TIMING RESULTS\n",
      "----------------------------------------------------------------------------------------------------\n",
      "  E2E Inference:  54.59 ms (18.3 Hz)\n",
      "  Backbone Only:  35.84 ms (27.9 Hz)\n",
      "  Action Head:    10.39 ms (96.3 Hz)\n",
      "\n",
      "----------------------------------------------------------------------------------------------------\n",
      "SPEEDUP SUMMARY (vs PyTorch Eager)\n",
      "----------------------------------------------------------------------------------------------------\n",
      "  torch.compile E2E Speedup:      2.14x\n",
      "  torch.compile Action Head:      7.50x\n",
      "  TensorRT E2E Speedup:           2.72x\n",
      "  TensorRT Action Head Speedup:   9.08x\n",
      "\n",
      "====================================================================================================\n"
     ]
    }
   ],
   "source": [
    "# Final comprehensive summary\n",
    "print(\"\\n\" + \"=\"*100)\n",
    "print(\"FINAL COMPREHENSIVE SUMMARY\")\n",
    "print(\"=\"*100)\n",
    "print(f\"\\nHardware: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'CPU'}\")\n",
    "print(f\"Model: {MODEL_PATH}\")\n",
    "print(f\"Action Horizon: {policy.model.action_head.action_horizon}\")\n",
    "print(f\"Denoising Steps: {policy.model.action_head.num_inference_timesteps}\")\n",
    "\n",
    "print(\"\\n\" + \"-\"*100)\n",
    "print(\"PYTORCH EAGER TIMING RESULTS\")\n",
    "print(\"-\"*100)\n",
    "print(f\"  E2E Inference:  {np.mean(timing_results['e2e_time'])*1000:.2f} ms ({1000/(np.mean(timing_results['e2e_time'])*1000):.1f} Hz)\")\n",
    "print(f\"  Backbone Only:  {np.mean(timing_results['backbone_time'])*1000:.2f} ms ({1000/(np.mean(timing_results['backbone_time'])*1000):.1f} Hz)\")\n",
    "print(f\"  Action Head:    {np.mean(timing_results['action_head_time'])*1000:.2f} ms ({1000/(np.mean(timing_results['action_head_time'])*1000):.1f} Hz)\")\n",
    "\n",
    "print(\"\\n\" + \"-\"*100)\n",
    "print(\"torch.compile TIMING RESULTS (mode='max-autotune')\")\n",
    "print(\"-\"*100)\n",
    "print(f\"  E2E Inference:  {np.mean(compile_timing_results['e2e_time'])*1000:.2f} ms ({1000/(np.mean(compile_timing_results['e2e_time'])*1000):.1f} Hz)\")\n",
    "print(f\"  Backbone Only:  {np.mean(compile_timing_results['backbone_time'])*1000:.2f} ms ({1000/(np.mean(compile_timing_results['backbone_time'])*1000):.1f} Hz)\")\n",
    "print(f\"  Action Head:    {np.mean(compile_timing_results['action_head_time'])*1000:.2f} ms ({1000/(np.mean(compile_timing_results['action_head_time'])*1000):.1f} Hz)\")\n",
    "\n",
    "if TRT_AVAILABLE:\n",
    "    print(\"\\n\" + \"-\"*100)\n",
    "    print(\"TENSORRT TIMING RESULTS\")\n",
    "    print(\"-\"*100)\n",
    "    print(f\"  E2E Inference:  {np.mean(trt_timing_results['e2e_time'])*1000:.2f} ms ({1000/(np.mean(trt_timing_results['e2e_time'])*1000):.1f} Hz)\")\n",
    "    print(f\"  Backbone Only:  {np.mean(trt_timing_results['backbone_time'])*1000:.2f} ms ({1000/(np.mean(trt_timing_results['backbone_time'])*1000):.1f} Hz)\")\n",
    "    print(f\"  Action Head:    {np.mean(trt_timing_results['action_head_time'])*1000:.2f} ms ({1000/(np.mean(trt_timing_results['action_head_time'])*1000):.1f} Hz)\")\n",
    "\n",
    "print(\"\\n\" + \"-\"*100)\n",
    "print(\"SPEEDUP SUMMARY (vs PyTorch Eager)\")\n",
    "print(\"-\"*100)\n",
    "compile_e2e_speedup = np.mean(timing_results['e2e_time']) / np.mean(compile_timing_results['e2e_time'])\n",
    "compile_ah_speedup = np.mean(timing_results['action_head_time']) / np.mean(compile_timing_results['action_head_time'])\n",
    "print(f\"  torch.compile E2E Speedup:      {compile_e2e_speedup:.2f}x\")\n",
    "print(f\"  torch.compile Action Head:      {compile_ah_speedup:.2f}x\")\n",
    "\n",
    "if TRT_AVAILABLE:\n",
    "    trt_e2e_speedup = np.mean(timing_results['e2e_time']) / np.mean(trt_timing_results['e2e_time'])\n",
    "    trt_ah_speedup = np.mean(timing_results['action_head_time']) / np.mean(trt_timing_results['action_head_time'])\n",
    "    print(f\"  TensorRT E2E Speedup:           {trt_e2e_speedup:.2f}x\")\n",
    "    print(f\"  TensorRT Action Head Speedup:   {trt_ah_speedup:.2f}x\")\n",
    "\n",
    "print(\"\\n\" + \"=\"*100)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}