{ "cells": [ { "cell_type": "markdown", "id": "7d61605b", "metadata": {}, "source": [ "# Basic Usage Tutorial for SPIDER + Mujoco Wrap\n", "\n", "This is a minimum working example to show how to use SPIDER. Please make sure you have Nvidia GPU and CUDA installed. Create environment with `uv sync`. " ] }, { "cell_type": "code", "execution_count": 5, "id": "0ac81149", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "env: MUJOCO_GL=egl\n" ] } ], "source": [ "%env MUJOCO_GL=egl\n", "\n", "import io\n", "import os\n", "\n", "import imageio\n", "import mediapy as media\n", "from IPython.display import Video, Image, display\n", "from huggingface_hub import snapshot_download\n", "\n", "from spider.config import Config, process_config\n", "from spider import ROOT" ] }, { "cell_type": "markdown", "id": "aa0fb10a", "metadata": {}, "source": [ "## Prepare Dataset\n", "\n", "You can process manually by referring to `spider/process_datasets`. \n", "Here we use our example dataset where I already downloaded some example data from common datasets. " ] }, { "cell_type": "code", "execution_count": 6, "id": "bd8576fe", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dataset already exists.\n" ] } ], "source": [ "# Check if the directory exists\n", "dataset_dir = f\"{ROOT}/../example_datasets\"\n", "if not os.path.exists(dataset_dir):\n", " print(f\"Dataset not found at {dataset_dir}. Downloading from Hugging Face...\")\n", "\n", " # download the repository to the specific folder\n", " snapshot_download(\n", " repo_id=\"retarget/retarget_example\",\n", " repo_type=\"dataset\",\n", " local_dir=dataset_dir,\n", " local_dir_use_symlinks=False # Ensures actual files are copied\n", " )\n", " print(\"Download complete.\")\n", "else:\n", " print(\"Dataset already exists.\")" ] }, { "cell_type": "markdown", "id": "627c2d1b", "metadata": {}, "source": [ "## Prepare Config\n", "\n", "Choose parameters for your task. " ] }, { "cell_type": "code", "execution_count": null, "id": "63b5d4fc", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "\u001b[32m2025-12-22 11:26:48.540\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mspider.config\u001b[0m:\u001b[36mprocess_config\u001b[0m:\u001b[36m263\u001b[0m - \u001b[1moverriding ref_dt: 0.03333333333333333 from task_info.json\u001b[0m\n", "\u001b[32m2025-12-22 11:26:48.540\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mspider.config\u001b[0m:\u001b[36mprocess_config\u001b[0m:\u001b[36m269\u001b[0m - \u001b[1moverriding contact_site_ids: [4, 7, 11, 14] from task_info.json\u001b[0m\n" ] } ], "source": [ "# choose parameters\n", "# for dexterous hand\n", "# task = \"lift_board\"\n", "# embodiment_type = \"bimanual\"\n", "# data_id = 0\n", "# robot_type = \"allegro\"\n", "# dataset_name = \"oakink\"\n", "# max_sim_steps = -1 # max step to run, -1 for unlimited\n", "\n", "# for humanoid\n", "task = \"getup\"\n", "embodiment_type = \"humanoid\"\n", "data_id = 0\n", "robot_type = \"unitree_g1\"\n", "dataset_name = \"lafan\"\n", "max_sim_steps = 1000\n", "\n", "config = Config(\n", " robot_type=robot_type,\n", " embodiment_type=embodiment_type,\n", " task=task,\n", " data_id=data_id,\n", " dataset_name=dataset_name,\n", " viewer=\"\",\n", " max_sim_steps=max_sim_steps,\n", " use_torch_compile=False, # for jupyter\n", ")\n", "\n", "# humanoid specific parameters\n", "if embodiment_type == \"humanoid\":\n", " config.sim_dt = 1 / 60\n", " config.ref_dt = 1 / 30\n", " config.trace_dt = 1 / 30\n", " config.horizon = 0.8\n", " config.ctrl_dt = 0.1\n", " config.knot_dt = 0.1\n", " config.joint_noise_scale = 0.1\n", " config.joint_rew_scale = 1.0\n", " config.pos_rew_scale = 3.0\n", " config.rot_rew_scale = 3.0\n", " config.contact_rew_scale = 1.0\n", "\n", "process_config(config);" ] }, { "cell_type": "markdown", "id": "1b9c4f3e", "metadata": {}, "source": [ "## Process Dataset\n", "\n", "More dataset processing pipeline can be found in `spider/processed_datasets`. Dataset instruction can be found [here](https://facebookresearch.github.io/spider/development/add-dataset.html). \n", "\n", "In this step, the following things will be done:\n", "1. convert and copy mesh\n", "2. read finger tip, object and wrist position and rotation" ] }, { "cell_type": "code", "execution_count": 8, "id": "6fcc7b9a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Processed directory: /home/chaoyipan/Research/code/spider/example_datasets/processed/lafan/unitree_g1/humanoid/getup/0\n", "fps: 30\n", "qpos shape: (5045, 36)\n", "copy from /home/chaoyipan/Research/code/spider/spider/assets/robots/unitree_g1 to /home/chaoyipan/Research/code/spider/example_datasets/processed/lafan/assets/robots/unitree_g1\n", "copy from /home/chaoyipan/Research/code/spider/example_datasets/processed/lafan/assets/robots/unitree_g1/scene.xml to /home/chaoyipan/Research/code/spider/example_datasets/processed/lafan/unitree_g1/humanoid/getup/0/../scene.xml\n", "Saved task info to /home/chaoyipan/Research/code/spider/example_datasets/processed/lafan/unitree_g1/humanoid/getup/0/../task_info.json\n", "Saved trajectory to /home/chaoyipan/Research/code/spider/example_datasets/processed/lafan/unitree_g1/humanoid/getup/0/trajectory_kinematic.npz\n", "Saved video to /home/chaoyipan/Research/code/spider/example_datasets/processed/lafan/unitree_g1/humanoid/getup/0/visualization_kinematic.mp4\n", "rollout ik tracking error: \n", "pos_err: 3.52\n", "quat_err: 1.99\n", "joint_err: 0.74\n", "Saved video to /home/chaoyipan/Research/code/spider/example_datasets/processed/lafan/unitree_g1/humanoid/getup/0/visualization_ik.mp4\n" ] } ], "source": [ "if dataset_name == \"oakink\":\n", " from spider.process_datasets.oakink import main as process_dataset\n", "\n", " process_dataset(\n", " dataset_dir=dataset_dir,\n", " embodiment_type=embodiment_type,\n", " task=task,\n", " show_viewer=False,\n", " save_video=False,\n", " )\n", "elif dataset_name == \"gigahand\":\n", " # NOTE: for gigahands, you might need to use their own conda environment to process\n", " # their data\n", " from spider.process_datasets.gigahand import main as process_dataset\n", "\n", " process_dataset(\n", " dataset_dir=dataset_dir,\n", " embodiment_type=embodiment_type,\n", " task=task,\n", " show_viewer=False,\n", " save_video=False,\n", " )\n", "elif dataset_name == \"hot3d\":\n", " from spider.process_datasets.hot3d import main as process_dataset\n", "\n", " process_dataset(\n", " dataset_dir=dataset_dir,\n", " embodiment_type=embodiment_type,\n", " task=task,\n", " show_viewer=False,\n", " save_video=False,\n", " )\n", "elif dataset_name == \"fair_fre\":\n", " from spider.process_datasets.fair_fre import main as process_dataset\n", "\n", " process_dataset(\n", " dataset_dir=dataset_dir,\n", " embodiment_type=embodiment_type,\n", " task=task,\n", " show_viewer=False,\n", " save_video=False,\n", " )\n", "elif dataset_name in [\"lafan\", \"amass\"]:\n", " from spider.process_datasets.gmr import main as process_dataset\n", "\n", " process_dataset(\n", " dataset_dir=dataset_dir,\n", " dataset_name=dataset_name,\n", " embodiment_type=embodiment_type,\n", " task=task,\n", " show_viewer=False,\n", " save_video=True,\n", " )\n", "\n", " # show saved video\n", " video_path = f\"{dataset_dir}/processed/{dataset_name}/{robot_type}/{embodiment_type}/{task}/{data_id}/visualization_kinematic.mp4\"\n", " Video(video_path, embed=True, width=600)\n" ] }, { "cell_type": "markdown", "id": "36f3057e", "metadata": {}, "source": [ "## Decompose mesh\n", "\n", "Mujoco doesn't support mesh decomposition, so we need to decompose the mesh manually. " ] }, { "cell_type": "code", "execution_count": null, "id": "901b2b6b", "metadata": {}, "outputs": [ { "ename": "SyntaxError", "evalue": "invalid syntax (3971784330.py, line 3)", "output_type": "error", "traceback": [ " \u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[9]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[31m \u001b[39m\u001b[31mif\u001b[39m\n ^\n\u001b[31mSyntaxError\u001b[39m\u001b[31m:\u001b[39m invalid syntax\n" ] } ], "source": [ "from spider.preprocess.decompose_fast import main as decompose_mesh\n", "\n", "if embodiment_type != \"humanoid\":\n", " decompose_mesh(\n", " task=task,\n", " dataset_dir=dataset_dir,\n", " dataset_name=dataset_name,\n", " embodiment_type=embodiment_type,\n", " data_id=data_id,\n", " robot_type=robot_type,\n", " )\n" ] }, { "cell_type": "markdown", "id": "6fae02a2", "metadata": {}, "source": [ "## Detect Contact\n", "\n", "This step is optional, where contact mode is detected with mujoco collision detection. " ] }, { "cell_type": "code", "execution_count": null, "id": "a5f23a10", "metadata": {}, "outputs": [], "source": [ "from spider.preprocess.detect_contact import main as detect_contact\n", "\n", "# no need for humanoid since it has been done in previous step\n", "if embodiment_type != \"humanoid\":\n", " detect_contact(\n", " task=task,\n", " dataset_dir=dataset_dir,\n", " dataset_name=dataset_name,\n", " embodiment_type=embodiment_type,\n", " data_id=data_id,\n", " show_viewer=False,\n", " save_video=False,\n", " )" ] }, { "cell_type": "markdown", "id": "f28ebdbb", "metadata": {}, "source": [ "## Generate Scene\n", "\n", "Create mujoco scene by compiling objects and robots together. " ] }, { "cell_type": "code", "execution_count": null, "id": "9e1e6b92", "metadata": {}, "outputs": [], "source": [ "from spider.preprocess.generate_xml import main as generate_xml\n", "\n", "if embodiment_type != \"humanoid\":\n", " generate_xml(\n", " task = task,\n", " dataset_dir = dataset_dir,\n", " dataset_name = dataset_name,\n", " embodiment_type = embodiment_type,\n", " data_id = data_id,\n", " robot_type = robot_type,\n", " show_viewer = False,\n", " )" ] }, { "cell_type": "markdown", "id": "9130850b", "metadata": {}, "source": [ "## Run Kinematic Retargeting\n", "\n", "Run kinematic retargeting for specific embodiments. \n", "\n", "IK objective is to match the finger tip position and wrist position/orientation. " ] }, { "cell_type": "code", "execution_count": null, "id": "b737a18d", "metadata": {}, "outputs": [], "source": [ "from spider.preprocess.ik import main as run_ik\n", "\n", "if embodiment_type != \"humanoid\":\n", " run_ik(\n", " task=task,\n", " dataset_dir=dataset_dir,\n", " dataset_name=dataset_name,\n", " embodiment_type=embodiment_type,\n", " data_id=data_id,\n", " robot_type=robot_type,\n", " show_viewer=False,\n", " save_video=True,\n", " )\n", "\n", "# show saved video\n", " video_path = f\"{dataset_dir}/processed/{dataset_name}/{robot_type}/{embodiment_type}/{task}/{data_id}/visualization_ik.mp4\"\n", " Video(video_path, embed=True, width=600)" ] }, { "cell_type": "markdown", "id": "54c0c2ec", "metadata": {}, "source": [ "## Run SPIDER\n", "\n", "Finally, we get everything ready and can run SPIDER. " ] }, { "cell_type": "code", "execution_count": 10, "id": "70a3c69d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Warp 1.11.0.dev20251120 initialized:\n", " Git commit: bf8830d11365ac5061c779c55b5278d733076d4f\n", " CUDA Toolkit 12.8, Driver 13.0\n", " Devices:\n", " \"cpu\" : \"x86_64\"\n", " \"cuda:0\" : \"NVIDIA GeForce RTX 5090\" (31 GiB, sm_120, mempool enabled)\n", " Kernel cache:\n", " /home/chaoyipan/.cache/warp/1.11.0.dev20251120\n" ] } ], "source": [ "import mujoco\n", "import numpy as np\n", "import time\n", "import torch\n", "\n", "from spider.interp import get_slice\n", "from spider.io import load_data\n", "from spider.optimizers.sampling import (\n", " make_optimize_fn,\n", " make_optimize_once_fn,\n", " make_rollout_fn,\n", ")\n", "from spider.simulators.mjwp import (\n", " copy_sample_state,\n", " get_qpos,\n", " get_qvel,\n", " get_reward,\n", " get_terminate,\n", " get_terminal_reward,\n", " get_trace,\n", " load_env_params,\n", " load_state,\n", " save_env_params,\n", " save_state,\n", " setup_env,\n", " setup_mj_model, # mjwp specific\n", " step_env,\n", " sync_env,\n", ")\n", "from spider.viewers import render_image, setup_renderer, setup_viewer, update_viewer\n", "from spider.viewers.rerun_viewer import log_frame\n" ] }, { "cell_type": "markdown", "id": "9a02aa6c", "metadata": {}, "source": [ "prepare datasets, optimizer and environment" ] }, { "cell_type": "code", "execution_count": 11, "id": "335cbe81", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Module mujoco_warp._src.smooth 4d4b71e load on device 'cuda:0' took 2.38 ms (cached)\n", "Module mujoco_warp._src.collision_driver e72006d load on device 'cuda:0' took 0.24 ms (cached)\n", "Module _nxn_broadphase__locals__kernel_5e1f554f 5e1f554 load on device 'cuda:0' took 0.26 ms (cached)\n", "Module mujoco_warp._src.collision_primitive._create_narrowphase_kernel f36229d load on device 'cuda:0' took 18.02 ms (cached)\n", "Module mujoco_warp._src.constraint 4a3aa8f load on device 'cuda:0' took 1.23 ms (cached)\n", "Module _actuator_velocity__locals__actuator_velocity_c93b8b76 1845902 load on device 'cuda:0' took 1.56 ms (cached)\n", "Module mujoco_warp._src.passive fc4f8e1 load on device 'cuda:0' took 0.54 ms (cached)\n", "Module mujoco_warp._src.forward a88f545 load on device 'cuda:0' took 0.68 ms (cached)\n", "Module mujoco_warp._src.support 769a44d load on device 'cuda:0' took 0.24 ms (cached)\n", "Module _tile_cholesky_factorize_solve__locals__cholesky_factorize_solve_373adaac 0c61f4b load on device 'cuda:0' took 29.19 ms (cached)\n", "Module mujoco_warp._src.solver 1699532 load on device 'cuda:0' took 1.58 ms (cached)\n", "Module mul_m_dense__locals___mul_m_dense_4285c9ac 1c942a9 load on device 'cuda:0' took 41.94 ms (cached)\n", "Module update_constraint_gauss_cost__locals__kernel_6a81ae08 6a81ae0 load on device 'cuda:0' took 1.50 ms (cached)\n", "Module update_gradient_JTDAJ_dense_tiled__locals__kernel_8bfc7d5f d0e8b58 load on device 'cuda:0' took 64.99 ms (cached)\n", "Module update_gradient_cholesky_blocked__locals__kernel_ddf8d1b3 4ec5a3d load on device 'cuda:0' took 118.83 ms (cached)\n", "Module linesearch_jv_fused__locals__kernel_02653c95 02653c9 load on device 'cuda:0' took 3.54 ms (cached)\n", "Module mujoco_warp._src.derivative fda8455 load on device 'cuda:0' took 0.56 ms (cached)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\u001b[32m2025-12-22 11:27:39.448\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mspider.viewers\u001b[0m:\u001b[36msetup_viewer\u001b[0m:\u001b[36m106\u001b[0m - \u001b[1mviewer is disabled, launch dummy viewer\u001b[0m\n" ] } ], "source": [ "# load reference data (already interpolated and extended)\n", "qpos_ref, qvel_ref, ctrl_ref, contact, contact_pos = load_data(\n", " config, config.data_path\n", ")\n", "ref_data = (qpos_ref, qvel_ref, ctrl_ref, contact, contact_pos)\n", "config.max_sim_steps = (\n", " config.max_sim_steps\n", " if config.max_sim_steps > 0\n", " else qpos_ref.shape[0] - config.horizon_steps - config.ctrl_steps\n", ")\n", "\n", "# setup env with initial state from first sim qpos\n", "env = setup_env(config, ref_data)\n", "\n", "# setup mujoco (for viewer only)\n", "mj_model = setup_mj_model(config)\n", "mj_data = mujoco.MjData(mj_model)\n", "mj_data_ref = mujoco.MjData(mj_model)\n", "mj_data.qpos[:] = qpos_ref[0].detach().cpu().numpy()\n", "mj_data.qvel[:] = qvel_ref[0].detach().cpu().numpy()\n", "mj_data.ctrl[:] = ctrl_ref[0].detach().cpu().numpy()\n", "mujoco.mj_step(mj_model, mj_data)\n", "mj_data.time = 0.0\n", "images = []\n", "object_trace_site_ids = []\n", "robot_trace_site_ids = []\n", "for sid in range(mj_model.nsite):\n", " name = mujoco.mj_id2name(mj_model, mujoco.mjtObj.mjOBJ_SITE, sid)\n", " if name is not None:\n", " if name.startswith(\"trace\"):\n", " if \"object\" in name:\n", " object_trace_site_ids.append(sid)\n", " else:\n", " robot_trace_site_ids.append(sid)\n", "config.trace_site_ids = object_trace_site_ids + robot_trace_site_ids\n", "\n", "# setup env params\n", "env_params_list = []\n", "if config.num_dr == 0:\n", " xy_offset_list = [0.0]\n", " pair_margin_list = [0.0]\n", "else:\n", " xy_offset_list = np.linspace(\n", " config.xy_offset_range[0], config.xy_offset_range[1], config.num_dr\n", " )\n", " pair_margin_list = np.linspace(\n", " config.pair_margin_range[0], config.pair_margin_range[1], config.num_dr\n", " )\n", "for i in range(config.max_num_iterations):\n", " env_params = []\n", " for j in range(config.num_dr):\n", " env_params.append(\n", " {\"xy_offset\": xy_offset_list[j], \"pair_margin\": pair_margin_list[j]}\n", " )\n", " env_params_list.append(env_params)\n", "config.env_params_list = env_params_list\n", "\n", "# setup viewer and renderer\n", "run_viewer = setup_viewer(config, mj_model, mj_data)\n", "renderer = setup_renderer(config, mj_model)\n", "\n", "# setup optimizer\n", "rollout = make_rollout_fn(\n", " step_env,\n", " save_state,\n", " load_state,\n", " get_reward,\n", " get_terminal_reward,\n", " get_terminate,\n", " get_trace,\n", " save_env_params,\n", " load_env_params,\n", " copy_sample_state,\n", ")\n", "optimize_once = make_optimize_once_fn(rollout)\n", "optimize = make_optimize_fn(optimize_once)\n" ] }, { "cell_type": "markdown", "id": "f185ea87", "metadata": {}, "source": [ "run retargeting" ] }, { "cell_type": "code", "execution_count": 12, "id": "bce18ca1", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABaAAAAHgCAIAAADc1V3gAADxM0lEQVR4nOz9d3gc15Unft/qruoc0MgAQYIEGMAclJMpS5RGlke2pbFkaxRtz8gT7Fnn3ef5Pc847M5O9sw4vB7b67FlOcj2yEm2LEuyMiVKlBjABJBEzkADnbty1fvHUV8VGg0QABEI6ftZLwbsrq6uKgio0+eee65g2zYDAAAAAAAAAFjJXMt9AAAAAAAAAAAA5wsJDgAAAAAAAABY8ZDgAAAAAAAAAIAVDwkOAAAAAAAAAFjxkOAAAAAAAAAAgBUPCQ4AAAAAAAAAWPHE5T4AAAAAgPn74he/SN98/vOfX94jAQAAgOUl2La93MdQDJEKAAAAzAaPGQgiBwAAgLezC2uKyhe/+EVnpFIUtQAAAAAAAAAAlHQBJTimpjMwDgMAAAAAAAAAs3Eh9uBAXgMAAABm4/Of/zxmtgIAAAC5UHpwIDoBAAAAAAAAgHm7gKaoAAAAAAAAAADMDxIcAAAAAAAAALDizWGKyhe/+EXn/BFnT9Dp5pXMdRsnzFUBAAB425pT6/GiEGW6x88ZlswmbgEAAIAL1mwTHOdcsXW6AGKhtgQAAIC3g7nGBtO18ZrNYvP0khm2RCgCAACwgizMFJXZ5yzYrIdHEFIAAAC83cwpiliQt5t5hwv7dgAAALCo5r9M7DlrO9nsEh9FgyfIawAAAMAMlRoLss+Se5vTgA0AAABcaOZZwTGbNETRNshcAAAAwAxmHu3gD84v9XDOsGS6DZDpAAAAWCnmk+CYR3aj6EHECgAAAFDknAEGbTCPIZNZ7hkAAABWtDlPUZm5h3nJ7wEAAABmb4Z2XchuAAAAwHQWpskoAAAAwPkr2XrjnK1AAQAAANhyJTgwVAIAAAAlff7zn5+ukTnSHAAAADCD+a+iMgPkLwAAAOB8TNe364tf/CLCDAAAAChpURIcAAAAAAsCS7cCAADALC3kFJXZLJKC+lIAAACYzmyCBAQSAAAAUNJi9eAoGXzwBxGaAAAAQBEKDxAkAAAAwPwsYpPRqZNmF++9AAAAYKWbuRSUP4geHAAAAFDSAvfg+PznP+8MSqZLaiA0AQAAgBlgXAQAAADmauErOM6ZvEB2AwAAAEpCFAEAAADzJti2PctN57Ewm3P45ZyvxcJvAAAAQKZWcMwQJEwXQpwztDj/DQAAAODCMYcEBwAAAAAAAADAhWkRm4wCAAAAAAAAACwNJDgAAAAAAAAAYMVDggMAAAAAAAAAVjwkOAAAAAAAAABgxUOCAwAAAAAAAABWPCQ4AAAAAAAAAGDFQ4IDAAAAAAAAAFY8JDgAAAAAAAAAYMVDggMAAAAAAAAAVjwkOAAAAAAAAABgxUOCAwAAAAAAAABWPCQ4AAAAAAAAAGDFQ4IDAAAAAAAAAFY8JDgAAAAAAAAAYMVDggMAAAAAAAAAVjwkOAAAAAAAAABgxUOCAwAAAAAAAABWPCQ4AAAAAAAAAGDFQ4IDAAAAAAAAAFY8JDgAAAAAAAAAYMVDggMAAAAAAAAAVjwkOAAAAAAAAABgxUOCAwAAAAAAAABWPCQ4AAAAAAAAAGDFQ4IDAAAAAAAAAFY8JDgAAAAAAAAAYMVDggMAAAAAAAAAVjwkOAAAAAAAAABgxUOCAwAAAAAAAABWPCQ4AAAAAAAAAGDFQ4IDAAAAAAAAAFY8JDgAAAAAAAAAYMVDggMAAAAAAAAAVjwkOAAAAAAAAABgxUOCAwAAAAAAAABWPCQ4AAAAAAAAAGDFQ4IDAAAAAAAAAFY8JDgAAAAAAAAAYMVDggMAAAAAAAAAVjwkOAAAAAAAAABgxUOCAwAAAAAAAABWPCQ4AAAAAAAAAGDFQ4IDAAAAAAAAAFY8JDgAAAAAAAAAYMVDggMAAAAAAAAAVjwkOAAAAAAAAABgxUOCAwAAAAAAAABWPCQ4AAAAAAAAAGDFQ4IDAAAAAAAAAFY8JDgAAAAAAAAAYMVDggMAAAAAAAAAVjwkOAAAAAAAAABgxUOCAwAAAAAAAABWPCQ4AAAAAAAAAGDFQ4IDAAAAAAAAAFY8JDgAAAAAAAAAYMVDggMAAAAAAAAAVjwkOAAAAAAAAABgxUOCAwAAAAAAAABWPCQ4AAAAAAAAAGDFQ4IDAAAAAAAAAFY8JDgAAAAAAAAAYMVDggMAAAAAAAAAVjwkOAAAAAAAAABgxUOCAwAAAAAAAABWPCQ4AAAAAAAAAGDFQ4IDAAAAAAAAAFY8JDgAAAAAAAAAYMVDggMAAAAAAAAAVjwkOAAAAAAAAABgxUOCAwAAAAAAAABWPCQ4AAAAAAAAAGDFQ4IDAAAAAAAAAFY8JDgAAAAAAAAAYMVDggMAAAAAAAAAVjwkOAAAAAAAAABgxUOCAwAAAAAAAABWPCQ4AAAAAAAAAGDFQ4IDAAAAAAAAAFY8JDgAAAAAAAAAYMVDggMAAAAAAAAAVjwkOAAAAAAAAABgxUOCAwAAAAAAAABWPCQ4AAAAAAAAAGDFQ4IDAAAAAAAAAFY8JDgAAAAAAAAAYMUTZUVd7mO4sNjLfQBTie7SeSjDtM5rv/YFeK4rm9vtnvqgaZpLfyRvZ263m645fhwXpqk/IEGYtMH5/mW7MAjn3uQti/+I2eRfQ/z2zexCuCWXjDcW/VcS0cjc4QZ3IUC8cUETBNHtoj9fi/VJajm8naOLqaaLN8STZ7r4P0zTZozZU26yfp93uv3ai3BbWvBdLsJBLtgOF/bQpktXuV1v/GI7f7hmqd/qGX7WC2Ix/oOZ2wEs79szxhiTZaXk4+4pf39L/uUN+H0Lf0xvIZlsLhwKzuklJX8iU+OVUsGK4Pef+1fmAr8bCcKSHmA2lw8FA3M6knP+ZSu8ftKfNcFx4f1+z1yPc3qLcrkW76ewqD/ekoedzcmhoH/q47qu8+8p3ihiM3v296AVEX6whT/OCyX8mO1vJWOmZRXecdJbLna8MbO3STQyfbwxmxsc8yPemNGCxRvilB+HUSpE93sv5HBiiWOJ2eDxxuyPreRfNkEQXC6BTY4rSn6MYucVbyC6cO58VnvP5eRgqXhDPNM9wObxh95mjDFV16d7rWvKHY7ZNr/JTeXzehwbzuFg5nTgs9/z1CzPDJsu+LvTxnlFDZzf7X+hbp+zjGNsRxxTdBB+n4ctXDyxULtZgF3YjDGWk+Wgv8Rv11JS1BI/o1KBZomzdv72vQVk83IoMLcfx4L/jZYVbeqDUxNYpmnx2xm/a87841ik28li3v+K95zLy8Fz/YDmdDRzPXi+vTz5t4Z+BFNvXvRnTZi8KZv+JyXMMUaZ+/HPafN5vcX8wqzCi/KyGiiV+Ct5GLO8L6iaPvVB27bdLlfJ11vTfKie+fdrhYUfbMEikJysBKd8lF3AFMDsd6RME29M94s51WzuaCs3GpnHDW5hzSWxVeK8KBpcDMuSsCq6nS3ejXSG5+gnUvTWpeKNJfpxLFI4Mb/dTo03lia6KKKoJWJCNuXPmiDM9GftLRBasPlFFzO+QpZV50AjPySxvaN35t3O6l57rk3OeS8puYGq6dO9+xv/TUx+2nL+ZzF5h16vZxbHMPPzbObzPM/9T325rKhTxzfm9wd8fvfy+bxqLq9QNK3wRpMed7sm/bdsF/1k+eO2PadP5vM5m9m9Ji8rF2BVxdyi5Cm0Uh8npv4tK/mj8S5rxiSfVwKBaX8c8/zkRq89v9v2+by65Kc7562R9l3y1sh/Tc7n3Ce9zfnsQBDO8QM612WazSGceyez2MssftwlNlA1TZjyFI38FCWz5vS7M5v/9hbkysxym5nfj9+8iv6TK9rzbP7Anvvv2GwilFlEIKUTKMxmJQdsGLNKfnpjjDHm9UhzPYZlDz9KxhvzPJoZ32jJXlV0iDzecHJNDjboJTP/FV2QwzufaGSuP6kLn1rqR8NmndLyeZY13phv+LeM4cTM766oJf4SsimRuVnqP2Jh9j+OhYglZrPZdJ9+p93teb/v4kUXRaZG6bTXqb84bwYbk9/X65GWMrSY7WazDUAKI1Wl/iQKgiB29A4UPXqOv7znuElP++wML5vpVTM9NdOBzHKHmm7QA0VRlKvkz8C2rcLLi/bjmfIrPd2RT3tGUx7OK0rA53M8P+vxnznePC+EYag5HMO5Ni2KU+mAS0eo1psFmc6deqf/A13y9M+/1mYlmut/ZiUzJjP9IXbwlPrAMJ2pf+zmk2OeV/gwj9fMM8qZzxlN+mfpH4fgKjqHqT8OQRA80jl+HDOflPMv28znMcN+ZkrWzPDMDDuc8VBmeO4cL5zvCTrfU9On/rCE4s9mjDHGbCo2mbzbol+f84zwzvFyQWCMKarq83qnPPzGT23mW8O8I5BzZBBm2uVSRCDTVKAw5viY7Xw727Knu1D0CziPM5rhdGRF9XtndReb4519saKRudXazCF8mv1emaZpJV8y9XfTtOySPzHvlL+l53x/WVH8vkUZUFn2OTsLpeTvGpt1vFEyQTmd6arVuLdeLDHXF+maUWIPU35HSv7n55Fm9Qm8xP55OeE08flbO7o410Wb9llN14vLVYU3d+jcq10qwy8IJT4On/td2ZtvMcPT0z2jqprX65n6vNjdNzx162nvjtP87Z32r+Ic77LT72aO+5k2h1DqibnuxPHElP8Uil8jiiKzC5vYjm3tSa8TCq80jMIfAkFwCS7LdtaklD6eN14/ZbMZfncdZyHMvLH95pDjtLt7Y1eOLabUT/JDL/V2gmMToejR6d9aONcGpZ4u/WdLKP5W142SA7Cl6hdsxpjbJeSnmebKpvkkObMZMiyLaumnT86yBZdaqrpvmqSVZZpWye35L65zvMhmjtOe/DtvM8bsGWIdu8R3pf/tfMaezWYz7Wy2SeRS/xJmuR1zbM0YY7m8XLwl/dLzUkDR5XjVpHMs+uU3DNPlcr05fYCemu7AnH8wnYr+Q7WL/8LMUfElFQRhymW2nWmd6e7EM+YrpnnJDH+qp3lmfoFU0RO6USLoZKU/A9hTj0eSpJmiqyknVSI8msUdtviplRCBzC38mP4FJR+eIfwo/A5OvvLFN9Y3Iw/DmPS31+VyOTP+b5r6Y55jKDLlmCY9WhSKTLex7Xh0ul+LN/c2bTRS4g9Fie/soveYJm55c2fniKOm7OnNXxC1aLRcYGzKXA++MdUvuFxCNieX3H2JD/bnCHnmNngwSwtQKrjwbDbreCMvF2/m/Ik4//O3LMswzLxc+gZkM5vCP5vN8FvzxhMUabxFYwn+gnPHEue+UoxJpfq5Tt2S/sS5XIUPKUUXbLqPbksdXdiskLNm57i5T/8mc4wu5pcZmTbsmem4BDZphGbSn1ue5BIKR1oq4SgIApMk8c0tZ31s4ht1pMIb72dP2o6/Kf8DLzi+Z6GAv2inkzabtLHAbLvwOEskM8wR7ghvbuV48I2XC3y//L2ce576EnpGONdLph7AbN79zR3O+t3n/da11eXDYxPO4y/xfckHnaGA86fJGGOsoizi2KY46GSC4/8X7/jNmPjN/8icN+xS70v/x+vxTH6FULxZ6dcKjLHxZGqasyvxYNFPvGi70pdxSswxywPjr62vqRwcibNzWbw2B5WxyJy2V0sl1KfjnePwL2NsPJGa0/Gc05wuXV11xdDo+KSxUMezkx63p70jO6OHyS+ZZlfMriiL8l3YkzctepWmG1PfvWS8IknSm/uceniTToyNJ1OlDqz0ARf/c5pzL97bNKc/3fFP96Z20T9t5wUrfsR2PjH5JeXRiM2mbOl4C5vZzGaark/e1ZtbFI7HZjbzeKSizRyXedK+x5Npx0OTrsDkc3Hs33n1nGc9+SpNvRSzuRpFB2OXeuF0BxOLht78J92mp3kL54Xlpl4ETTMkj8go9/3mrmzGWCqTm3RXLXyZOQLh/UoF/ih/8dS/86Vu+rOJQIpSMDPHAJNu6AsRAxQdwOzffaHCj7pCvDH5khbfJYs3KPXZnj9YXjrYEKZsX7QBo7+QhSOYeqOfdENwXiUaGyh5MFPv+M4TFARGv9QlT6r0KU+6KRU/OPurdK4DK95zXU3l0JR4Y/GiC+chlZeF5/qqN3+Us+DxSHNKjvBb3vk4z0tXX10xODrOZnc/nWUsMekNpmxGv1YzvcrxrTPnNV3wYzs+YBfdzqZuzBgbT6bPM45i53H6pffGzrHZdNHFm/90fj/lZhqLRuyiFxTChkl7sJmmayWji6Jj8kjidNFF0SFPJNL8MKaJBBynUxRIFF+E4uii6M1mCM9KxjlTXjj50G07VhYuTqOVeouZQgt+jZhzG560sjXd8EjipOtgM8ZYJpcXb73pHZNvlpPu8bO5XxbumvSleCezv0+XRUKljmG6HU7eVal313XDeesQJr2msDF9P+WQ2JQj8Xo8/AWTvxQf0jmPX2Askco67m6ld1VTVT4aTxTdyQv/d6bbbckAxRE0znTfFQTB5/XwGWtvvpyVfDkrUiIFMOU/p8m7cxw2m/LaUmc0dR/TbZ/NySVOdbrdOnal6Tof1pj6xlPPWtONxRgGmfzuK8ycgoZSFfgzmXmKhKbrRRuUHmidvEXJXU13D+Xf0fDgdAmF2ex22ghgum1KbjCrF775/aQBwGkPZtIhlz54xz8m9fGaLsPy5k3Snkhm+LOTb+9vbjn1dj415VAqOnEeW6mAYOq9/zzeeoZ3j0VD9oyHyt9X0w1nwOEMi/i72jbzSOLUhE7Jw0gkM87Lf47DmBzEnDuCefPHWLxDxlh9TdXA8KhtT9m3bRuGea6P61PvnqW3L3pw9hFILBLmwcDUY5hr+KEbxpvxBONv9sYjk8OOacIPx/97I5s802U5R/hRtHEynZ3FFRYEgdVUxkYc8UbRRS7+ftJ9USh6dtLteuaQYMqHfOdtQxCEWOET9aSXT9lRybvN1LcuEQQ4vp0pFJm0WfFFyBX+nBY9VbRd8ak6j2LqZZ8a1RSe0nTjnJME52HxMySLaXZHP9dIg9EUiXPt0yNJ57zvzzKWYFP+ns+wz6KHS8cS5wwkiraZYywx6bim7DRL9RrT7b/Ug+c862DAPzmbM1NwkkhnlzK6mO4WvyBvPfO7l0VCJd966vtqmsHejC/4dpNeKHmkEjf3olfYjDGWSGUmH+HUKzbpP8VzZmpY0YPT75D+76paijfefJZvLFDjpTfuf1PTEEWfUybfSieV5U+OPFjJP+MlPhsLjv/PN3bGK6V3PuW4BJ3yxFP+FJW8RU3+V/EGJfYx7VPTHB4AAKxYk26h0z5b/MD0G7zxj1LBnfPbKc87HpAksUQgOM0jRQcwdXyP/k3rttqTHp98DIUHJVGc9n0d7xLweXnXPdtmNo83bGYz2zJtZ4DhvKuWDD9Y0SeXWUcgcws/GCsZgcwQfhQ9Ml0EMkP44Xig5KfiErtB+AEAsNLNJbo4j9CCzTa6oAkg84supgst3jwwm7E3Jv6X3Lgo/cEkSZwaXTgTK7QZ9XGzmZ2XlTea7lG8wc/WtgV7mksMAAAAAAAAALBSlOjSBwAAAAAAAACwsiDBAQAAAAAAAAArHhIcAAAAAAAAALDiIcEBAAAAAAAAACseEhwAAAAAAAAAsOIhwQEAAAAAAAAAKx4SHAAAAAAAAACw4iHBAQAAAAAAAAArHhIcAAAAAAAAALDiIcEBAAAAAAAAACseEhwAAAAAAAAAsOIhwQEAAAAAAAAAKx4SHAAAAAAAAACw4iHBAQAAAAAAAAArHhIcAAAAAAAAALDiIcEBAAAAAAAAACseEhwAAAAAAAAAsOIhwQEAAAAAAAAAKx4SHAAAAAAAAACw4iHBAQAAAAAAAAArHhIcAAAAAAAAALDiIcEBAAAAAAAAACseEhwAAAAAAAAAsOIhwQEAAAAAAAAAKx4SHAAAAAAAAACw4iHBAQAAAAAAAAArHhIcAAAAAADwlnU2n1/uQwCAJYIEBwAAAAAAvDUNMTbS17fcRwEASwQJDgAAAAAAeAsaYuzoyEhtOLzcBwIASwQJDgAAAAAAeKsZsO1+0zx16FBzff1yHwsALBEkOAAAAAAA4C2l1zTHBGF8YiIiCMt9LACwdJDgAAAAAACAt44uVY273YphDPX0lLnweQfgbQS/8AAAAAAA8BZxNp+PSxJjLJVKjfT1bW5uXu4jAoClgwQHAAAAAAC8FbSn0+Ner8flUnV9fHh4pK9vCxIcAG8nSHAAAAAAAMCKd2xsLO71+txug7FkMjkxMrKmsnK5DwoAlhQSHAAAAAAAsLLFVXUiFAp5vTZjqmGkJyZS4+Pvvvrq5T4uAFhSSHAAAAAAAMAKNibLx3Q96vczxhTbTieTmWQyMTqqKcpyHxoALCkkOAAAAAAAYKUazedfz+XKQiEXYwZjsixnkkk5k0mOjW3buHG5jw4AlpS43AcAAAAAAAAwH0OZzBFFqa6qcjNmMKaappLL5dLp5Ph486pVy310ALDUUMEBAAAAAAArT38i8WoqVVFZKTJmMWYxpsiyKstqPp/PZG69/vrlPkAAWGpIcAAAAAAAwMoz6HZX19Z6BIExRr1FdU3LplL5TCaXTKpowAHw9oMEBwAAAAAArDCvJJO63+8TRRdjFmMaY5qm5dLpfCaTTaXW1tbu3LJluY8RAJYaenAAAAAAAMBK8lI8bkejfklyM2YzZjBmWlY+k1FyOTmXk3M5S5aX+xgBYBmgggMAAAAAAFaM54eHXRUVPLthMmbaNnXf0FVVyeXkbPb2m25a7sMEgGWABAcAAAAAAKwMf+jpsaNRSRDcjAmM2YxZjJmmqSsKrZ+i5HKZRAINOADenpDgAAAAAACAFeBUMumqrAz4/S7GBEptMKaapqaqci6nyrIqy4aub1izZve2bct9sACwDNCDAwAAAAAALnQnE4lhSQoFAiJjLsbswvwUyzTlXE7XNMMwVFmWs1mm68t9sACwPFDBAQAAAAAAF7QTExMDLpc/EKDJKa5Cb1HdNDVFMQxDzmaVXM7QdTmX++Af//FyHy8ALA8kOAAAAAAA4MJ1MpHos6xgKORxuejTi1mYn6JrmqooSiZj6LquqvlsNp/Nbt2wYZmPGACWCaaoAAAAAADABerE+Hg/Y+Fo1Ot2i4wJjDG+NKxpGrqua5qmqvTVMs31DQ3LfMQAsHyQ4AAAAAAAgAtR6+hor2WVVVR4JclVyG5Q7YZl27qmaYoiZ7OmYeTSaU1VVVkWsH4KwNsYpqgAAAAAAMAF58jQUK9lRcrLfZIkMuZmjBV6i1qMmZZlGoZlGKaua6pqWZaay2WSybtuvXWZjxsAlg8SHAAAAAAAcGE5NDDQz1ikvNzn8fCZKYwxizGNMdO2DV1XZVnO53VNy2ezuqpalqVks9s2blzO4waAZYUpKgAAAAAAcAEZyeX6bbu8qsojih7GBMYER+2GzZhpmkouZ5mmqeu6rhuqaup6Pp3egvaiAG9vSHAAvH0lEglBEMrKypb7QAAAAOCto6OjgzFm23Ymk1FV1e/3u1yul1566eqrrzZNMxQKaZoWiUTC4bBt25FIpOjlw5nMgUQiUl7udrloWgplN1ghwWGYpq5ptm1rikJNRg3DkHM5TdOSY2NLe64AcGFBggPgbaenp2d4eNjr9brdbkEQent7Ozo6WlpaTNMUBIExFolEKNqIRqPLfbAAAACwApw9e9Y0zfHx8bGxMdu2LcsSRZEiCkEQRFG89tprBUEQBCGXy+m6fvLkydWrV4uimMvlotGopmnr1q1jjKmieCCRKK+uljweyeVyTZ6cYjJmMGabpmkYhq7T4im6qtL8FFWW/+pP/3QZLwIALDskOADeRlpbW7u6umKxWDAYdLlcgiDYtv3zn//8+uuvHx4etizL6/Xatj0xMZFOp10uVyAQKCsra2xsRJUHAAAAlNTe3n769Gld103T1DRNURRBECzLymQy27Zte/7556uqqjZv3ixJUnt7e2Njo6IojLGamppcLscY0zQtlUr19PScOHHCX1lprV9fVVcnejwet9vNmMuxLuwbi6dYlq7rhqYZum4Yhqaqhqoamqaraj6d3t7SsqwXAwCWGRIcAG8LR48e7e7uHh0dra2tVVXVNM2+vj7GmG3btbW1R48edbvdkUjEMIzTp08/88wz9FRDQ8Oll166ZcuWVatWrV27FmkOAAAA4Nra2o4fP57NZnVd7+rqqqioYIy5XC6Xy+Xz+VavXq2qKqU2MpkMYywWix08eNA0Tdu2GWP5fD4Wi6XT6f/+7/9mjFWvW3fn3/5tdU2NPxymNVOc68LS/2zbNnWdUhu6ouiKYui6YZqmaWqK0tLUtIxXAwAuBAL9fQGAt7ADBw4cPHhQ1/WysrJYLEaTU9xut23buVwun89blhUKhaLR6ODgoGEYg4ODjLHXX399cHDQtu1AINDc3HzFFVfs3LmzvLy8rKwMmQ4AAIC3ME3TRFF0uSattzgxMSGKoiAIsixXV1c//fTTP//5zxsaGqgmlMpC6ZOFJEnBYDASifj9fkmSBEGgbV599dXKyspIJEIZEL/fPzo6apomY2xwcNC/ffu2a64JRqOiIEiFtR6p+4bJmM2Yzphpmqosa6qqZLP5TCabTuczmXw2m56YGB8c3Ltjx91YIxbg7Q0VHABvZaOjo4888kgymWSMeb1ev99v2zaNnFAdaTKZ1HWdMVZTU6OqajabFUWxvr6eMVZfXz84OEhpjuPHjx87dmzVqlVXXnllS0tLXV3dunXrkOYAAAB4a1AUxbIst9stiqJt24IgjIyMBAIBwzCo34Vt25qmeb1eURT/7d/+7Y477nj22Wfr6uro5ZZlnT592rbt7u5uTdOuvfbasrIyGkoxTdPlclmWZRjGunXrVFWVZZkxFg6HLcvq7e2tq6sbGRlpuvHGsrVrvX6/WxCkQuGGq7BmCqPWG5ZlGgb9T1MUTdMMw9A1Tc5mLcMwTXP7pk3LdP0A4EKBBAfAW9Zzzz334osvMsY6OztTqdS+fftoKIaGWUzTlGVZ13XbtoPBoN/vHxgY6Ovrq62tTSaTbre7vr6+vr6eYpeBgYFDhw4NDg7+7Gc/Kysr27lz5549e9avX79u3bpYLLbM5wkAAADzlU6n8/m83+8PBoNut5s/Hg6H8/k8ddagHIdlWZQH6enp6erqcrvdmqadOHFieHiYXuJyuTweTygUqq6upokqjDHqX06NMzRNsyyLMebz+URRlGV5eHi4urq64dprI42N/lDI6/W6GRMKk1MotWEVKjhMy9IUxTQMU9dN07QMwzIM0zAEQZBzuVw6vXPLliW/fgBwYUGCA2AFyOfzLpfLMAyXy6Wqqs/nkySpv7+/rq6OYg5Zlmniq23bJ0+e3Llz509+8pP29vZkMtnV1ZVMJq+44gqqEeVxhmEYmqZRKWlVVRVjrL+/P5fLud3umpoaPoBD+6Rkx+Dg4KFDh4aGhp577rnnnntuzZo11113XWNjY1VV1bp168rLy5f1IgEAAMAcpFIpWZZN06RUhWEYgiDouu5yuSRJsiyLeoXKsky1GFSO0d7e3tPT093dbdt2dXX1mjVrhoeHT506NTEx4fF4TNN817vexRijl1A6g15LZSD01pIkKYoyPj7e3Nzs3by5srk5HIvRorDilEVhbcpumKah65Ztm4YhZ7O6ppmmqcmyVVhRZdOaNct2KQHggoEEB8CFK5/PU/LC4/EEg8FgMCgIgs/no+KL8vLyfD5PEYllWcPDwy6X6+zZs//7f//vb37zmydPnuzr6+vq6qJd1dbWBgIBPkvWsizTNGlyiiiKbrc7n8+n0+mqqioacuGpENu2qSWHy+WiNIdt25Tm6O3t/d73vlddXX3RRRdt3bq1sbGxubkZBR0AAAAXvlwuNzo6SoMfNGuVURLBMBhjLpfL7/e73W5d1ynrQcGDbdt/+MMfamtr9+/fv3379sbGxtHR0WQymUwmN23atHbtWsuyVFWNRCKSJLFC+QbfM09w0Gr0fX19jdddV7FhQyAScblcXpdLYExwrAtLqQ2DOozaNuUydE2zbdsyTTmTMS2LVorVFOUDf/InS30RAeDCgwQHwAUqmUym02lRFEVRZIxpmqbruiiKkiRRi9BUKkVFFpTgIA8//DBj7Fe/+hXNfZVlOR6Pf+hDH8pms5SzoOpT27apypQxVl5eLsuyoii0Xj1PbdBmjLHq6moq90gkEtQS7KKLLmKMDQ0Nvf7660NDQ7/73e9+97vfNTY27t27t6mpqbKysqmpCZkOAACAC9aZM2eCwSBlLmzbpsINuu9TpUY+n6eYgUZETNP0er2WZQWDwbvuuuvo0aPhcJgxFo/H29vbb7/99pGREVmWQ6EQlYQURR3OBIff7xcEQdM0f1PTqu3bRY/H5/NRS1HX5OwGrZzCGKNhGcMwLNO0TNPQdV3TmMtl6rplmpqiqLL8zDPPJEZHW1paKisrl/xyAsCFAgkOgAvR+Ph4Op12u92WZdGS8pTFEARBFMVwOEwDKdT6i3p3maaZSCTOnDnDGIvH4xs2bIjFYpFIhIo7ysvL3W43VWdQHENjNYyxQCBg2/aRI0eoxKOoZToN19D8W1mWx8bGLMuqqKioqqqqq6v74z/+Y57m6O3t/f73v19VVXX55Ze3tLREo9E9e/YgzQEAAHChOXnypCiKtHwJn0jinE5CWQ+atEIxwMjISH19/dDQ0Be+8AWfz3f8+HFqSW7b9rZt29asWdPd3c0YKysrc01G21AYQ+8eCARkWTYrKzdfdJHX7/f6fEJhUViONrULtRtvdAFRVVPXdU0zdJ3mp+i6rmuaqiiZROKJ3/52pL//2LFjW7Zsqa6u3rx58xJeUQC4UCDBAXDBoSQFxRZUoMFni1BSQ9d1SZKoK4eu6x6Ph4KG/fv3l5eX19TUxGKxNWvWHDx4MBAIKIoSDodpLIUPpOi6Ti8JBoOBQCAejw8NDW3evJmWf6MpKqwQ5VBtCBVxKIoyNjZWWVkpCMKhQ4c2bNhA81YEQRgYGKBMx6OPPvrYY49t2LDh9OnT69atW79+fXl5OTp0AAAAXAgSiUQymQwGgzRwwss2WaFy0/k9L74IhUKyLHd1dQUCgYsuuojKSzOZTD6fr6+vr6io6OrqWr16tW3bFKIwxnjLUooi+M49Ho8cjUqNjeFo1C2KLsbEQu1G0eQUSnAYhmEahmWaNmO6pqmybJmmrqqWZVFBh66qajabHB194oknGGOrVq264oorxsbGNm/eTF3GAODtAwkOgAtLX1+fLMter5dqNBhjlOZwLi9PS7W53W7DMGhIRBRFXdcnJia+9rWvtbe3j4yMMMbKy8uPHDnS1NTk9XolSaK5LYzWkFdV2nl1dbVlWQMDA7x8g1dwOId0KL6huo9cLldVVTU8PDw4OCgIAoU1kiStWrWKGpEODw8PDAy0t7e3tbXV1dXRyrItLS3r169frqsKAAAA5Omnn66vr+fZDeeohvOrc/UTCgBGRka2bt168ODBNWvW+Hy+cDh88uTJ3t5euvVXVFSUlZWpqkpRB4UcvO2Xc36KUVkprVoVjEQkn88jii5HdkMo5DUYNRZlzDTNN4Z3aFRH0xhjmqapsmwahqFpuqYZmnb9ZZeV79vHq0ofeeSR/v7+d7zjHX+CxhwAbzNIcABcQMbHx3t7e2n+KmOsqJKCIgPKdDDG+L0+lUpVVlaOjIx86UtfEgTh+eefj8Vihw8fHhoaamhooB6ifAkVHqnQO1IzjlwuV1lZSeUbzvaijDEqTI1Go2vXrtU0raqqKp/P+3w+VVW3bNlCk3Kz2azH4/F4PKIoUppjz549fMmVn//859XV1bfddptt2xs2bFiuawsAAAD79+/3eDyapvGbviiKNH2Vl47SljzTYRgGTZVVFMXn8zU2Np48eZKvIl9fX3/mzJlLLrlElmUet9A3JeenaLGY2Njo9ft9fr8kii7G3FOyG7x2g47A0DTTNA1NswyDkiWmrjPGDF23LEtXVTWfp8Cmtrb23e9+9/Dw8OHDh1999dVVq1adPHlyC9aOBXg7QYID4AJy8uRJXmThjDbo2aKwg49niKKoqmp9fX0+nxdFsaurKxaLDQwMbN26laINj8fDu29Qe3PaJ63M0tbWpuv6+vXrfT5fNBoNhUJ8ZsrY2Jhpmo2NjS6X66mnnhIEob+/n57duHHjNddcMzQ0dObMGUVReBDDz6Wuru7d73730NAQpTl+9KMfhUIhxhhyHAAAAMslkUhQPKBpGqUhLMvyeDy8bpQVlj6h2z3NTtU0TZbl/v5+Xdc3btx46NChyspKWoS+u7t7165dW7du/c1vfrNq1Sqan8KbjLJCDQhFCK66ukhLi+TxeP1+aqIuOBqL8rwGK7QXpXQGxSRUr2Houknlq4ZhW5ap66Zh5HO56lisr6+voqJCFMXa2tp3vetdIyMjvb29r7/+ejAYbGxsXJarDQBLDwkOgAvFwMDA+Ph4ZWWlaZp0L5ckiRduOFEIUlj3XVdVVdf1UCg0NjbW3d29bt26bDYrimJ1dXVbW1skEqGJshRn0FJwtM+qqqpcLtfZ2bljx47Gxkafz0cRCb2LbdvUf5QyKe94xzs6Ojosy3rqqads2/71r39tWda6deve9a53NTY2xuNxTdOcU2mGhoZqampqa2tvvvnmoaGhw4cPHzx4MJVKIcEBAACwLHp6euLxeFVVFVVVdHR0bNq0ybZtWp2NMcYXUmGFjl2ZTEZRFEVRRkdHI5FIW1tbfX19IBAIh8OHDh1av359bW2toignTpyIxWIUBjgXiOXzUxhjRixWu327PxTy+P2iKFLA4XYcnjO7YdJX2zYty7QsQ9Ms09QNw7IsXdMsXTdN09B1VVF0XY/5/bZtV1dXK4qSSqWovNTv91977bXHjx8/ceLEP/zDPyztlQaAZYMEB8CF4pVXXqF2odRfgzIFNKjCt+FhB20my7Kmab29veFwOBQK+Xy+/v7+VatWtbe3m6Y5OjpK00Zo/RR6Oe++EQwGGWOapq1atWr16tWhUIgiEid7si1btliWtXnzZmo7evbsWdM0f//7369Zs2bNmjW81ym9sLKyUpZlGheqq6urq6vr7u6uqan55je/+dGPfnQJricAAAA4vfrqq4FAgIY9bNtuamrSCi0tAoEADwPopq8oSj6fl2U5l8sZhjExMVFTU9PS0nL27FlVVWtqamzbdrlcAwMDmzZt6unpEUXRtm2KOpw1p5qmWZZlVVRU7tjhCwYD4bBHkqjvhtHX193dXRkI0DJvTBAEQQjW1lqMWYGAYNuaJJnUYZT6iRqGqetmIbtB1Ry6omxeu5YiE2oZlk6n165dK4qix+MJh8Ojo6O/+tWv3vve9y7XZQeApYQEB8CFYmJiYtWqVVQxQUEDH1RxNjmnsENV1Xw+n8/nTdMcHh72+/2PP/74ddddFwgEent7GWOVlZW02AqVgdAeaCUUniXJ5XJjY2Mul+vXv/71TTfdtHbtWgpuqGTD2WG0CD2+detW+mqapmVZFANls9l8Ps+3VFU1kUi43W5RFK+44oqzZ8++9tprW7Zsueaaa5bnKgMAALwt9ff3K4pSUVHh9XrpEaoYJbquC4JAc1qLZqbQ156eHl3X6+vrM5kMzfhwuVyRSCSbzQqCkM/nN27cODEx4ZxaywqdvOxAILp5czAc9lMugzEXYx2/+U1jVdXGWKy4BVgiwRjzJxK2bYctizGWNk0ejViiaEUicVHUvV4jHC5bu7ajp8fK5+3CkvY0AuT3+91udz6fP3LkCK1zvwxXHACWAxIcABeEAwcOlJWV8UmwvJ+orus0qMIbdxmGoapqLpfTChKJxPr16ysrK9vb29euXev1eg3DaGho6Ozs9Pv9fG0Uy7Li8TgrlIFUVVVRg9LXXnvt6NGjhw8f/td//ddoNErJCFEUqcFHUZdTnuAoeoQqNcLhMFWiZrPZoaEhVVVN00wmk7W1tdXV1VRUoijKb37zG0VRbrjhhuW84gAAAG8nbW1tlZWVwWBQFEWqd3gj+1BYCJbu5hQA0NJpuq4bhjE+Pt7f308rvhuGQbf7wcHB5ubmVCpFi80HAoHR0VGv10sNOChooT1rmuarqwvFYt5AQPJ6RZfLxdiB7363ua7O7XZ7PB7qg84KM3CZo78pFYOUi2JRBFIVDPJHVldV0bkkk0lN006cOGGapiAI4XA4k8n4fL5EImFPme0LAG9VSHAAXBDa29tra2slSXKGHXzdE7rHM8YEQaCkBvXd0HX91KlTwWAwnU77fL58Ps8Y6+npCQaDNN9VFEVaqk0QBNM0A4FANptlhfaio6OjLpfr2LFjsVhMUZR/+qd/+r//9//S8dA7UtEHc4QaJb9xpjkoNvJ4PJFIRNO0eDwuCEJZWRkdZH9/P60zd/LkSSQ4AAAAlsbJkydN06ShFFaY6EpP0QwUqr6kaIHxygvbbm9vj0ajg4ODmzdvPnLkyIYNG2gPqVSqoaHh5MmTZWVl1dXVsVhscHCQMeZccp4KQxhjSne3Eg5HL7rI7XIJjI13d2vJ5H/+6lfl5eV33HFHS0sLX1bW2ZGUTV651pn+KApCKPyoqqqir5qmUbJjeHiY4hAKZgDg7QAJDoDl9/jjj69atSoYDNJIBWOMshvUQ5QV1k+hWzgNp9DSrX6/f/v27ZFIpKurq7y8PBqNMsYkSaLZp729vXZhEiy9VlEUekda7XVoaGhgYIBnQHp7e1988cW9e/fyxIrL5RJFkQ7GuaupkQePMOzC5BqKb2pra8PhcDweD4VCo6OjAwMDsVjMNM2DBw8ux5UGAAB42xkdHR0aGrIsKxAI8CXVKJdBhRuyLFNowQp5BMuyenp66uvrKyoqjh07pmlaPp9vaGhQVbWxsXFwcDAcDj///POSJPX393d1dW3dupXey5mSoOmuFCFMtLaGQ6GyLVvcjJ186qnu7u5XXnll7dq1//iP//jlL3+5urqawgw+JEOH4QwzKAPCphl04XkZd0E2m83lcrQm7q5du5b6ogPAMkGCA2CZnTp1iuodqFmGZVl0C9cLqN2Gz+ej+bGMsVAoVFVVRVWg2Ww2Go0Gg0FZls+ePWtZViqVGhoaamtrsyzL6/XS9BaXy1VTU0NdP+l9y8rKBgYGstms3++nphu2bf/kJz+56qqraHCGL2VPoQNNcqHH6RE+z5YnOHgehLZ0juHE4/GhoSFRFAOBgGEYmA0LAACwNF5++eX6+nqfz8fbi9JtPZ/P83VSaPiE7uCqqjLGXC5Xd3d3R0cHRSMDAwP5fH7v3r3hcLi1tZVeYtu21+vN5XLOoQ7DMHjwQLsiwuDg8Oho2aZNyf5+dzhcWVlJYcPXvva1L3zhCzxgEASBpsk4R1b4V378RU9RlMIjEBqq2bt3L2OstbV1+/btS3vJAWDZIMEBsJzi8fjIyEg0GvV6vVS+kUgkQqEQDadQsy5VVW3bpughHA7HYjEaMDl9+nQ2mz179uzExARjTBAECg74nmd+64qKilQqNTExEY1GXS4XzZIdHx//0Y9+9OEPf5i2ofEQj8dDQQzFKxQ9UFDCwxGOjoQ2oBSMJEnBYDCfz585c8bv99P2tGcAAABYVE8//XRVVZXf7xdFkd+1qSCUMSZJUjQaVVVVFMVUKnX48GGv10sZDbpZ05xZihCuvPJK2qdpmuPj4+l0OhgMUpXEwMCA1+ulW78kSW+sC+uYGOLz+Rhj493dnUeP+ny+3/z3f1OfDkEQOjs7v/Od7/zlX/4lbUnhBBWQ8rjCOazC265TsMEcKQ/eqZS+RiKRPXv22GjAAfB2ggQHwLIZHh5ubW2tqqqi7AalDyorKzVNo5CCpsjSYAiNq9TV1T3zzDPj4+Pt7e3OdMac0F0/Ho9nMhlRFCORCL2RJEmmab766qv33HMPtTulLb1eryiKVHPB8xq2YwU45ijrsG1b13VZlilfQyEUdWKPxWI0kmPbNq9lBQAAgEUyNjY2Ojra0tLCF2XjM1CoRIJPS7Ft+8yZMzRRhc855RHIzp07I5GIIAgbNmwIhUIf/OAHe3p61qxZY5pmd3e3YRg9PT19fX1er9fj8Xi93kAgQBNdafqt2+1OJpMjIyPJZDIej/t8voqKimQyKYoi5Vmef/75a665ZufOnc75JpQoKcpx0HnRg3xiLy8eoaiJFTqyq6pqGMZtt922PFcfAJYDEhwAy6a7u5tWa6NsQkdHR1NTE8UWNABSWVk5MjIiCMKRI0dqa2s3b978zDPPvPzyyxSjFO3NOWRRNMQxlSzLXq83m83W1NREo9FcLsdHdUzTPHDgwDXXXMMHQ2zbplkw2WxWVdWigZSiY8jn87Q3/qwgCIcOHfrlL3+5detWyqEYhvHBD35w4S4kAAAAlPDss8/+7ne/O3ny5MUXX7x582Z6kGc3dF2n6oxIJNLe3j42NsYKqQTajFqN3n333bt37/7tb397zTXX0LxX27YbGxsFQTh79mxHR4dt22fPnmWMDQ4OSpJEK9A7wxInn89nmubQ0FBFRUUgEKA1XE3T/NWvfrVz505WmF1CPcvdbjdvBObcCY92nDEJjabw4R+Xy3X27Nnvf//7mzZtuuSSSxb1OgPAhQMJDoDlcerUqSeeeOLKK68Mh8N0n25ububtvvgQiiAI4+Pj5eXlzc3N//Ef/2EYBk2gLYoYnGWZU5+dTnV1NY2x8CJPxpjb7X711Vcvv/xyencKFHRdd7vdwWDQ4/HYtk0jJLwHGI8z8vl8JpNhk/Msv//975988sl0Oq2qqt/vz2QyqqpiNiwAAMCiOnLkSEVFxW233ZZOp5955plDhw5dfPHF69evp96ffJ0UynTouu7xeGg5Nlaoibjrrrts27733nvPnj172WWXURDy+OOPnzhxglap5+26nIEHBSrTyefz2WzWtm2fzxcKhWRZliTJsqwzZ84888wz1113HZ+ZYhhGMBikZmQ8yJk6uELdN6gNKj94xtjo6OjDDz+cSqUsy+ro6Ghubl6wKwsAFzAkOACWx7PPPtvR0TE4OLhly5ZLL720qqqKhxo0tELf+/3+0dHRLVu2fPWrXzVNs2R2Yx58Pp9t28PDw83NzdQ73bnP7u5uRVGoToSiFmfDMI7Pj6UDlmU5m81Sk1Q+bvOb3/zmmWeeoWYcw8PDGzZsMAxj06ZN53n8AAAAMIO+vr6enp6amprq6mqfz/fOd75zbGzst7/97djY2Lp163w+H0Ua1Gc0l8sJgtDY2HjTTTfV1NTQHnbs2MEYGx4e3r9/fyqV8nq9Tz/99LPPPksjH+cTilAbUb/fT9EI7+F14MCBvXv30uwY2tIwDL/f7/f7VVU1C+gp54wV0zQzmYwzTNI07ac//amu65IkhUIhGn0BgLcDJDgAlsHzzz+/ffv2d7zjHcFgcP/+/b/+9a937Nixa9cuquDQdZ1aV1Bv86amphdeeEFVVUmSiio1WKF2QxRFah5W1GGL4oCp3UCpWXokEqGyC6r/ZIxRbkKW5eHh4ZqaGnohRQxF01KcmQ7TNHVd1zSNTa4affrpp3/729/SyIwoiuFwmKby3nXXXUt+yQEAAN5GTp8+HQqFPB4PhQeWZVVWVt57772//vWvf/Ob32zatKmpqSmXyymKks/n8/m8x+OJxWI33HCDcyeDg4MvvPCC1+t96aWX9u/fT4ujlUxtFHXHmBmt4Ob1ennLDNLT03P06NGWlhbeYoMvu0YDKs53p/pTikAymYymac461kceeaS/v9/lcnk8nng83tvbOzo6eskll8RisflcTQBYOZDgAFhqJ06c0HW9vLxcFEVBEK677rqmpqaHH3747NmzV1xxRTgcVlU1l8vpup7NZmVZ7u/vf+2115xdP1khg0BDGXyRecaYIAhUZepMRhQlJhhjgUCAVqWlfAo96HK5qFJDEISBgYHKyko2eXl553xaelOaJUsbUCkHPeVyuc6cOfP73/8+HA4zxqiDKa10u2nTJhoUAgAAgMVw+PBhRVHKy8v50AilA3Rd37t37zXXXPPwww9nMpnKykqqfVBVVdf1/v7+9vZ2Z5XlqVOnBEF47rnnXnrpJQpapr6XMHkRN+c2RR3B+D9jsRitMksZCt7wizG2f/9+PpeEjpl39eIDLUVDLNSanRVWhxEE4fXXXz9w4AC9Stf1Y8eOffCDH/T7/a2trWvWrFm3bt0CX24AuJAgwQGwpEZGRjo6Oqqrq2nlFEpSNDQ0fOITn+jp6Xn88cd37NhRWVkpy7KiKNls1jTNgwcPOusy+AQW+oZu/0UDJoqilHx3nqGgdhi0FBwPOHiQIQhCX18fLXQytbsHr9Hgb8qn8vKsRz6f/+1vf+vxeOgRt9ut63pnZ2dFRcX/+B//Y7EuLgAAwNvewMBAV1cXLQ0rSRItNUIlopqmaZomy/L111+/f//+wcHB+vp6anJBrTF+8pOf/O3f/i3t58iRI4ODgwcOHHjllVfcbvc8jsRZWMrjB0VRbNuWJEmWZZ6n4JNbjx49yldOoRpSnj2h5EVRjqNomIeCoueffz4QCNCDFOocPnz4hhtuMAyjt7d3cHDwqquuWpBLDQAXICQ4AJZUZ2dneXm53++ndWHpTkwxRywWu+yyyw4dOlRRUVFdXZ3JZPL5fF9f3/DwMK/IoDXPdF2PRqM+n4+amdMSa4ODgxTEzBCFCIJAz2qaZhhGNBp1Nifn6Q+q4OBdTplj+KWoioS+oeZevOcoY+zRRx9NpVJUy8pjDsYYPZhMJsvKyhbj8gIAALzNnTlzJhKJ8OwGBRs0RVRV1Ww2SzmOlpaWQ4cOtbW11dbW0oLu+Xw+nU7TToaGhg4fPtzd3f3iiy9SGUjJ96IeW6IoUqkFH7mhd6TiDsuyFEWhKpJ8Ph+NRmmyiaZpVHNBiQxWKDiNx+MUJPCMBr2WZzqcRal8iIUXcbz44ouJRMLj8dA2dOKnT5++5ZZbaJmVVCr1hz/84frrr1/EnwEALB8kOACWzvPPP2+aZllZmdfrpVJPmiRCMYeiKKFQ6JprrnnppZcURfH5fIyxQ4cO8Vt7JpMJhUKxWIwPidBsFK/Xa9t2Y2MjDWL09vZS4mPqAbjdblrHPpfL0ciGc+6rM5eRTCapPIQ5khrOb3i9KGOMQhmqNWWMDQ0NtbW1OSfIUIxi2/b69esFQTh58qSqqmVlZWvXrsVsWAAAgIVy6NChbDYbi8UkSaLuG3ahFzifAJvJZCijUVVV5fV64/G4KIr5fD4ejz/00EO0n9deey2Xy7344otTCzmZow+Xc3oI/0rBAK+qKOrhpShKKpUqKyujGlIeJNCzhmF0dnbSVFahsEQLL+igbYoiEGorRgM2qqoeOnSoaNjG5XKdOHHi2LFjbre7vr7etu10Ov3EE0/ceOONi/7zAIAlhwQHwBI5fvy4oiixWMzj8fBl5E3TpKIMGlHRNE1RlObm5vb2dsMwAoHA4OCg3++n6KS8vLxomqvX6y2qp7Btu6Ghoa+vjwZSplZzUNjh8/kymYxzmklRHQcVZVDkURTWsEK0wctEqfCV4ifG2K9+9Sv6xvlaOrYTJ0587GMfs217zZo11157bTKZjEaje/bsWfCrDQAA8DZ09uzZyspKn89H4yi8T5au6/l8nsIMXddN00wkEpQUEEVxbGzMNM1/+Id/oJ289NJLPT09+/fvHx4e5uUbdNOnwYx8Pu92u2l4g6czph6M80GeKBkfH6dgpuiF/F0GBga2bt3qLN/gO+EvpFNjhQQHn2978ODBZDLpzIwQQRAefPBBOtqGhoZLL7109erVbW1tLS0ti/BDAIDlhAQHwFIYHh7u6uqi7AatYUY5C7or00Kt+Xyepp+kUimqs+jp6aFqT0EQJEmiXdFYBDUG93q9tEaJaZqyLFNKgjFGAxQDAwPU6YMfBuUgXC6Xoiher9dZvsEKwYddWHyeD60wR/qDZsHwARyKMGi6LAU6g4ODo6OjzmIQ+krPejweTdNcLldvb+9DDz20Zs2avXv3JhKJhoYGrB0LAABwPh577LFoNEqTU2iqCB+EoHEUVVUp5JiYmKD2nJTsMAzjtttu27lzJ2Osu7v75ZdfZowNDQ3x/AKlNmRZFgRB07RIJMJ7nw8MDFBh6cyTZCn4YYzR1FrePqwozBAEobe3l47KuWYKz1kwxvjSbxRH8YkqjLGnnnqKFeIZvhmhk/V4PIODg7/61a/q6+vHxsYOHTr0p3/6pwv/kwCA5YMEB8BS6OjoiEQigUCAJoXyERVN07LZLPX3ouxGPB6nmzRNahUEwTAMr9fL12bj003z+Txz5DtY4Y7O0xY1NTXDw8OiKHq9XnqEprzy1hjOtVGYI8igOSy07CtNlOVhB5VmOLd3tviyLOvxxx/na9QzRxEHRSGhUIheoqqqIAhdXV09PT1r16695pprJElqampa1J8CAADAW9XQ0JBpmpFIhGIG/rGfGk8oikKRBn3Op+mxvPXG+vXr77zzTtrP/v37GWO9vb1DQ0M8UUI7qaioEEWRZzEoPqExFRpumWGSrKqq5eXljDFBEFKpFJvcrdxZqTE+Ps4THHZhnXvnBrxklUcgNNBy9uxZXkDKHOENxUUej8fj8aiqSv/s6+t7+OGHBUF47LHHPvOZz+zatWuhfyAAsDyQ4ABYdMePH5dlORKJUBUGDYNQyYau69TrS5ZlKh+lMCIQCFiW9eqrrzLG6FWUXKBgpWjlFLrrUyMxmnDLCjf+ysrK0dFRypWwQj9zyi/4fD6eieBxA/9qWZaqqrxqg7bkfUPoVRR2WAWMsdHR0YGBAec+eWaE9uDz+egUaOcUiHR0dHR3dz/00EPbtm378Ic/vHv37iX5sQAAALx1tLe3h8NhPjmFbrJUssG7b1CL8VQqRXGIpmm5XC6ZTP7N3/wN7aSnp6e/v18UxYMHD7JCYQV1Bo1EIs4CDT4N1uv18jYcDQ0NVMvpzIMQWpyeRlAkSSoqr2CORWRp2Vr+OB2DUFiM1hmEMMacy8k999xzfLf8VawwquT3++lVNH5DY0WCIPT19X3yk59kjO3YseP+++9HEAKw0iHBAbC4hoeH+/r6YrEYny1CtQw0FZbGUhRFURTFMIxcLmcYhiiKvJ8WZS4oJcGbXEyd70rZBCrN4KUfPHRQVdU5F1cQBGp47jxOihv4OEk4HJZlmTFGK7zahcXk6ZAoJuChBt/Vyy+/zPuSOktP+VnTq4pWsaUgw+Vytba2fupTn9q5c+d9992HCAMAAGCWRkdHNU0Lh8NUQEGf+ak+VNM0mgOraZplWel0mso3FEXJ5XLZbPZ973sfv+fSmik0gEFhQzqdjkajPFvB4w2/30+zVGjAxlngWVtbOzAwIIoiX8qEMcbv/oZh0Cry/KmiIRYKiugdhUK3L1YIUZzRBSVxaIN0Oj02NubsV8pfTiMrztakHNWAUFRz5MiRT3/60xSEoKADYOVCggNgcXV3d1O9KNVQ8EVhqVI0l8upqkrjDxRzKIpSVlZGgcLg4KDH46HRBr7M+3R9vOgWTtkHwzBoaMW27fLy8ng8Tsuy8HhCURS/3+8MAmj4hTagolBN0yhwKZolS9vzBApfo15V1Y6ODmcA4Sz3oHOk6bvOOSwcn7Zz+PDho0eP7tq1CxEGAADAbHR2dtLSsM6hFJpXksvlaH4KFXTwySkUhKxZs+a+++6jnXR3dw8MDPDMgiAItOQZBTDOeakUyQgFrNCWi/YjCEJtbe3IyIiqqnySrK7r9D2lG4qmsRQFJEUJDn48PN/hPBjaoL29ndd9OIs4+NWg0tHpIhAqg+VjLbquf/WrX0UQArASIcEBsIhOnTplGEYoFKJRDr5OmyzLzoDDNM1MJkMBB//8T127eC3ldKmNIvxmzxtu8eILKiIVBEHTNFpZlr+KV3LahUXX+EgLb0Lu7PXl/J6Pq7S3t+dyOWcexPkWlmWJokgHoCgK75nK0VAPrxBpbW39xCc+sX379vvuu+/iiy+e5w8AAADgre7EiRO6rofDYT6UQlNBqbEozYGlrATVcdDK9Pl8PplMfvzjH+f72b9/P68hpT7lgUCgqBKTakOcgyKUiaBhFV73wRirrKwcHh62bdvn82maFgwG6VW5XI4P5BDnPFk+SbYoo1GU7+CTZHn64+DBg9PVkJqm6Xa7ea1H0dWTJCkSifh8PhpkYoV8x2c+8xnTNLdv337//fdjuTeAFQQJDoDFMjIyMjg4WF5eTou58oBDlmUqv5RlmQojaX4KRR7hcJjuvn19fYwxmrHCplmAbTpUysFfEg6Hs9ksjwOoE5izdWhR3aYgCFVVVc7whX9TNFAjOHqaHjx40Dn31fmVrxdDyRfDMJwJDo/HQ0UuhmHQvBjeUfXkyZOf+cxntm3b9rWvfW1ePwQAAIC3ssHBwd7e3oqKCkmSMplMJBKhlVOpmSh1+6KOGzSmQqmNfD6fyWSck1O6u7tp2RT6J1VY0HQS6h1GEQuvJ2WOLhjMMamWpzls266qqhoeHvb5fMwRTlA9qbOCo2jEhRIctIqcM53BCuunOAs0aIN8Pj84OEhv5CwkYYWJtBT5OBMclMWg/miqqqZSKV4Mwl/ucrmOHTv2yU9+8v777//Qhz60sD84AFgkSHAALJaenp5wOEytN2zbTiQSNIihqmomk3G2MeeNzalLaNEqJGyO2Q3iTF7wEIRPKuEVHBRJTJ2wyuezTA0UnPvnX2VZpqZibHJ2gzkSHB6Ph47BeTqhUEgURUVRkslkUWzBGKM46cSJE9dcc8199933Z3/2Z3O9DgAAAG9hnZ2dZWVl1Fu0oqKCQgian0Krs1GhqHPNlEwmk8lk3v3udztXSN2/fz8f+ejv76c8AuUFKFZhhcmkRQfAp4FQAaargAcYiqLwwIPKSClpMsNJ0bRW5qgw5aGRszqDJ026u7upcSlzhB+UE+Frz1FDMcqb0EBLKBTSdT2TyRR1JeNvxHuEfe973zt06NBXv/rVuf50AGDpIcEBsCjOnDljmmYoFKJ2X7RyWzablWU5m83ymSl8FXqKOerr64tu4bOcmVKScw8ej0fXdVYYkeANO5wzU/irBEHwer1FZSBFM1qL3mhwcJBKM4oKTWkD3hWVN9qg0RtaLCadTpeMLZijybnL5fr+978vCMJHPvKR+V0NAACAt5h4PG4YBi1C7+z8TU2vZFmmZVMo2FAUJZPJJJPJRCJx6623OrMb3d3dw8PD/J+8AYckSTQtZTbRCG1D93cebJSVlcXj8XA4THdzmntStCvnKAtFLLajf/nU7Z1jLfT90aNHncuyOIdkeIKG4is6Krfb7fV6aWzpnBeZwqGjR49efvnlBw4cOOf2ALC8SqxTDQDnKR6PDw4OUoNxHnDQ/ZXmp9BACvXoovbmuVzO4/E411RraGjgNRfzRtkKZ78MmonKoxD+lWOMxWKxbdu2mabZ39/PH+fTbvl6bPxB27aPHDnCCnGVWWAU0MgJY4zKVRhjlEOhCzJddsN5FlTc8eCDD37nO985nwsCAADwlvHSSy8Fg0Hewcp2LA3LCx8sy6LsRjqdjsfjvb29N99881133eXcD5Vv8H/29fUJgiCKIlVSzHWshQcMfMyGhwSWZVH+wrlPe7JYLOYMNqwpnJGJbdu6rlMRKA85nF+phlSSJF45a5qmx+OhpM8sz4jeTpKkv/qrv5r9dQCAZYEEB8DCe+WVV0KhEK2cQgEHte9WFIVGQni7L13Xc7lcKpWKx+MUSdAeVFWNRCJFk0fOByUUCO9CWjJisCxr3bp1AwMDlmXV1NRQ7YlpmkNDQ5ZlZTIZZ2qD6LqeSqVmiFdo+itdB9u2vV4vLRHHF6CdDTrC//qv//rWt761INcEAABg5XryySfLy8s9Ho8oijRAYpomtRTNZDI0P4WKOGRZTiQSfX19+/bt+/3vf//hD3/YuZ+urq6JiQlryrqtdI8uOS3lnHg8YJqm3+/n2QeKgpij3MOeory8vGhYhec7nN/zYGZoaCibzRa9tTPJIjgWi02n0zwCmccZtba2fvvb357r1QCApYQEB8AC279/PzUWFUUxmUxS9YEsy6qq0kLx1FWUUh40nDIwMLB+/fqysjK+k1QqlU6nW1pazv946AAoABJFkS/UWjJcoFCjvLycd0o3DGN8fNy27aqqKsuy/H5/NBq1LCuVSk1MTFDk1N/fT4kP/o5FaFf0bDqdZo616+d0LpZluVyu//qv/zr/ywIAALByjY6OMsb8fr8kSbwZObUwz+Vyzp5Wqqomk8loNPrjH/+4qHCDPPPMM7SHIvPIa5R8OS13Qn1PqTS1ZHUGjxkikUgqlbIsKx6P27adTqd5eqLkq1KpFCsVe3B8UTkaaqLjmfd5fec73+np6TmfKwMAiwoJDoCFdPz4cdM0aTas2+0uLy+ndAYtRK+qKt2eqY15KpUaGhrau3fvT3/607q6OgoFRkdHe3p6aB5HPB5fkKMSHNxut3P0Y2qaIxKJVFVV8Uk0dqHJFt8yHo/TOVJ/UEEQ8vl8yZCCFQIOwzAonrAsS1VVURTnNyLECm3PUcQBAABvZ2fOnKHGoqIo0uwSvloZX6ON4o1MJjMwMHDzzTeX3E9XV9fY2FjRZA26R9OE1vM5SLswT5YKSN1ut9/vd2YonEUc/JGKigq/328YRjQaNU3T5/Ol02nTNLPZLLVHFQSBvqHQpa2trWQEwhyFJLRnRVGofON8zsvlcj344IMvvfQSJVYA4EKDBAfAghkcHOzs7PR6vZIk0fIf9NleLqDZp/Q1l8sNDw+/4x3vuP3221lhKCaZTNJIywMPPMAYq6ysPJ9BBuK8zTPGKMHhbKvO252SlpYW2oAvLFc0nbUo32GaZnd3N49OSmY6nBNtqOvqecZMKBAFAIC3rddeey2TyfAFWRljNJqiqmo2m6Uwwyysyz42NvY//+f/3LNnT8ldPf3008FgkM+QHRkZGRkZ2b17t7P08jy5XC5JkqjShI6taJTF2XGD1rvlj9P2fr/fsixfgaZpXq/X5/MZhpFOpxVFmW58hSIT3uBM0zRRFM8zAhEE4Ze//GV5eXl3d/eJEycSicQCXCMAWDhIcAAsmLa2tmAwSGMpztYbfHKKVei+oWnayMjItddee/fddzPGOjo6KC4pLy9/4IEHNm/e3NbW9sADD1BC4TzvxKywUtrHPvaxSy+9lKIE27apv6nhYJrmunXr6uvrqREXX8WWf+PMhvCndF1PJBLOERhnVMHHZOia0DBOyaVY5npGf/d3fzc+Pn6eVwYAAGDFaW9vp74bdGOlWktaJIW6b/T19VmWJQhCeXn5pk2bduzYUXI/nZ2dfX19VL5BXUgpaBkdHd2wYYOz7ej5oERM886dDZs2sULDUecwifPrxo0beXRhTsM53OJyueLxeNH4SlGFiDMT5OzmPj9UDEurzLrd7q6urkOHDi3AZQKABYIEB8DCGBoayuVyU4dTEolEKpXKZDJ0t7YsSxRFr9dbV1fHV2g7ffr0nXfeOTo66vF4GGNut/v06dOMsa985SsbN248z1wAhQKqqn7sYx/7/ve//+CDD/7qV7+6/vrry8rKKB1j23YoFPL5fGvXrt24caM2GXUpo6882cHrO2gDWgmlaEotjzOoAwgFYZqmUfv087zaLpertbW1q6uru7v7PHcFAACwggwNDQUCAb4iO5+HMjY2NjIyEgqFVFVdt25dMpkcGBhwu92RSGS6Xf3hD3+gOSPpdHp0dNR5S9V1fUESHJS2WL15871f+lJDS4vpWGFtag1pJBKpq6vjy52U5CzuoAqOkrGHEx9iCQQCC3JSfLc+n6+srCwQCLz88suYsQJwgSjRUggA5qG1tdXtdvORASrfGB0d3b9/f11dXSQS6e3tNU2zoaEhm83GYrGNGzfSlh0dHe3t7U1NTX/xF39x/PhxViihbGtra2lpKSsro1LM+S2nQrf8T3ziE3/zN39Dj1x22WWMse9///uMsQMHDtCd/he/+AVNrqEF6mlogs/spdXsTdMsWnGW8KboRevP83/quu71eumRQCDA62DPhyAIu3btKisry2QyJ06cqK2traioOP/dAgAAXOBef/11qtrgn+o1TWttbQ0EAp2dnZdddtnu3bu9Xm9/f38+n29vbw+Hw4cOHZo6RaWzs7O/v5/SH7SK6vbt29evX//MM88wxqqrq3t6eoommc4DDXIw2zZN84a77mK23XnsWNfx48IU5eXlV155JQUJFFC5XC4+aOSMMZxVorT+S1EE4tzMLCxVKwiCz+eTJOl8TofQuBFv3+52u0VRpOm6u3btOv/9A8D5QIIDYAH09fXF43FaBoVuqLqu9/b2dnd3B4PB1atXt7S0XHfddZlMZnR0VFGU7u7usbExeu0TTzxBDTjj8fiZM2e2bNmybdu29vb2s2fPplKpxsbGsbGxjo6O+eU4TNPcs2cPz24Uufzyy+mbSy+99KGHHvrv//5vn89nFtaHpxs2r0mhOIO/locXfK6vM/3BwxE+ckIvyefzgUBgrmdRkqZpkiRRVUhnZ2c6nV63bt2C7BkAAODC1N3dPTw8HIvFGGM0idU0zcOHD1dWVjLG7rnnnvr6+vb29sOHD/OXSJJEcyiKchxPPfVURUVFf38/Y2zDhg0XX3zxyZMns9nsn//5n3/729+mduMLMqHDNM2rbr3VMgzbtq+9446rb73V0LQzhw+rijLR1zdw/Lht2x6PZ9OmTTR/lt7XOQdnav6CV21QDSmbnNpgjgSH1+vldaO5XC4YDJ5/1qalpSWbzdKa99R5zev1ulwuWZZfeOGFrVu3lpeXn8/+AeB8YIoKwAJ47rnnqHEmn0dKKY+hoaGbb7758ssvn5iY+M1vfvPcc8+1tbXRgvMej+fYsWO9vb1dXV20hEpFRcXExERbW9vGjRtzuVwul2tra4tGozfffPOtt96qquqc2n1RbcXu3bt/9rOfzWb7e+6550tf+lI2m83n8/l8PpfL8a+0xq2iKPS9UiDLcj6fV1WV6jKKakd5/zC3200LzTLGqOX7+U9RsSzr9ddfp1bqHo8nGo1mMpnjx49PTEyc554BAAAuWGfOnOFzRakjeDKZZIxpmrZu3bp8Pv/www87sxuMMbozPvPMM21tbc7HX3nlFbfbfd9999Eqbw0NDS6Xa2Rk5OzZs3/+53/OGNu4cSMvf5gf27ZVVb3yfe9bs2WLZZqWadqWZVuWaZr1zc3Vq1fXbthQt3Xrvn37amtredRBXcko0lALnDNnCQUhiqI457nw2IPoui7LMq1PL4rigkySZYydOHEin89nMhk6YIrQPB5PMBisqqpqa2ujicYAsCyQ4ABYAJS257NGJyYmhoaGxsbGbr311mAw+MILLxw9epS2pDtrLBZrbm6WJKmzs1MUxerqav7s8ePH4/H4Bz/4wVQqRY2++vr6PB7PTTfdVFlZSeu2nvN4qGD1r//6r3/605/O/ix27tz5f/7P/2lubqYcRzabzRVks1me+yhKf+RyOZfLpU/G8x2aptHFobfI5/ML0pXdMIydO3cePHiQVqh1u92BQMDtdnd0dKArBwAAvFW1t7dTM9FsNktRR1tbWyKRqKmpkSTp1KlTU19i2/bIyEhHR0dnZyd/sLOzs66ujooj3vOe96xatYoxlkgkBEE4evQo5URaWlo0TTufu7ZhGB/5u7+79gMfYFRzYVmmYZiGoSmKoWmaohiGsaG5+e/+7u/e8573pNNpCjmckcbUkRX6SvL5vNfrnRp7cIwxSo7w4zn/1WGoSpdyTLlcLp1O05ErikJdOWKx2NjYWHt7+/m8CwDMG6aoACyAU6dOUWxBZYrt7e2SJG3atInqQksuIRaNRhljTz31lCiKvFSyrKzMMIznn39+7969DzzwwLe+9S16XFVVn893zTXXZDKZo0ePDg8PO1/lRHNGVFX9xCc+8YlPfGKuJ7J79+7du3czxo4XHDt2jE9UoWJR6sfBp/4ahlFZWbljx449e/akUqmXXnrppZde4tNSPvWpT1mW9e///u90FtQO7fyrQ1VVtW17x44dBw8erKys3LRpE7VulSQpm82ePHmytrYWBaIAAPAWQ9WUdMuj/uWCIESjUdu2u7q6crnc1Jf09PSoqrpp0yZ6lpal//Wvfy0IQlVVlWmaq1atevzxxysqKm6//fYnn3zS7/e/8MIL1dXVqVTqyiuvPHDggMfjmUdvTmq1vnbr1jd6YRSSC4ammYYhZ7NKPh8fGPjoX/wFY+yee+7ZsWPHj3/8Y4qgXC4X721BWZiiSbIUflDtRk1NTSqV2rlz50svveSc0mJZ1qc+9al//Md/5G1WaQqMJEnnE4dQyw8acHK5XJRmolRLMBgMBoNerzccDg8MDOi6vm3btvm9CwDMGxIcAOfrxIkTuVwuk8lIkuTxePx+P2OMFkaNx+MlsxsUZIyMjFDigD9O37vd7pdffvmKK64oehV1tLrkkktGR0ePHz9Ot0/+csuyJEnatWvX2bNn/+Zv/ub+++8/n5Patm0bvysfOXLE7XYfO3bs+PHjLpfrxIkTjDHTNFVVveeee3Rd/9CHPlT08hdffFEQhKuuuooxdsstt/DHdV1XFIVil3kfG9Ww0AjMjh07WltbLcvasmULVZ+63W5d17u7u7PZ7Jo1a+b9LgAAABcaTdPS6TT/zE/LpWuaJghCPB53bkmf4WmSyOrVqxljg4ODuVxudHS0o6MjHo9TH3HaMpfLHTt2bO/evU1NTYcOHUomk16vNxqN1tTU1NbW/vznP/f5fHO6cZummc/n7//Sl2j/dmHqiKHrhmFoiqLrei6dvu2GG/YUlrDduXPnzp07jx07duzYsRMnThw+fJju6XxwhackaCoKDefcfffdN9988z333ENPUfjBGNu/f//nPve5/fv3M8Y8Hk84HJ6YmKAEB+Vr5t27nd6d2qu/8MILe/bsEUVxZGTE5XKtWrVK07Ta2trKyspQKNTW1oYEB8DSQ4ID4Hxt3bo1m836fD5af8Tlcqmq6na7TdMcHBws+ZLR0dGhoaFnn33WMIxgMJhIJKg9WDAY5PNdX3311Wg0WnLVserq6uuuu46CD8aYoiiDg4Pj4+NlZWUNDQ21tbXXX3/9Ap4gtQTfvn07f6RkP3anq6++mn8vCEIoFGKMBQIBXtVJ9SDzOx7LshRF2bx5M/2Tchy06AzlOKiUJp/Pnz59uqqqipqxAQAArHSbN29+7rnnZFmmj/1UJREKhUZHR3Vd55vx2ay0DX2vadrRo0cjkchLL71ETTGdN+JkMnn69OmNGzc+/fTTjDGaJMsY83q9N91007Fjx8bGxuhNZz5CSmVcddtt195xB2VYWGHFE9MwDE2j2o1MMjnS03PXl75U9PLt27c7443W1lb6euzYMcpKHDlyZMeOHdu3b9d1fepYDg8/aIjlxRdfpKuRyWRUVaWCC03TaLW4eeQ4LMtSVXXLli00iOVyuVavXt3Y2Eg5Jk3TEolENpttb2+vqqoKhUKvvfbaxRdfPNd3AYDzgQQHwAKgblgul0uSJMpx0KzRksWitJjI8PAwja4424Pv27fvscce4wueRaNRn8+XSqUURSn5pqOjo+FwWBCEZDLp8/mi0WgymbzzzjtprGbxzJzdKLJ//35aXyYQCKRSKVmW+VWaR2xBwy9ut7uoF0k8Hu/o6Ni4caPb7aaV2zwej6IoXV1d6XS6sbFxrm8EAABwoTEMQ5ZlURRlWRYEgRbyGBoaCofD00274IuXaZrW0dFBi8gKgiCKb34K8Hg8lmW1t7e73W7qMPrtb3+bnqJJsldffXUmk2ltbaXiU2foQvjK8VfdeqtpWXtvv50voGZR6w3TNHXdpFEOVdUU5QN//MfnPN8dO3bwr/NAFRymadK0kaGhIVVVeWpjrjkOym7Isnz69GlJkmKx2C233CJJ0uuvv04b0IhOZWWl2+3u7e0tKyt75ZVXkOAAWGJIcAAsAFpnxO12p9Npr9fLGEsmk9MVDuRyOQpNDMOgj/rOaSwej4d6VRCfz+fz+ZLJZMlSDpJOp4PBIL1dIBCYOrdlGe3fv18QBFmWaQFaxpjX66VrJQjCXGML6uxFDcO2bt3KH6cijqGhodOnT99yyy2KotDKbVTams1mjx07VlNTw5u5AgAArEQ8wUGzNvx+fyaTsSyrp6cnFotRBMLZtj0xMSFJEv1T07T+/v7Vq1fzxeD5LdjtdluWJYpiR0cHY6y5ubnofWmS7MUXXzw6OprJZBKJRF9fH+2BqjPq169v3Lq1ccuWDbt2udxuoTD5xbZtWj/F0HVD1zVVNQ1DyeXW1tTce/vti3256CpRg1KaYmOapizLNMRCWZ5ZxiE02YcWdvnbv/3bmpqaZ599dmqWJ5PJZDKZcDgcCoWSyaQkSb/73e/e9a53LcrpAUApSHAALID3v//9jz32GGOMqh+z2ayqqn19faFQKBwOF01bHRoaYoydPn2aemi5XK5EItHR0cHjCVpI1XnXjEaj4XBYVdVUKsWbgZNMJsMYo+yGx+O5ALtOuFwuwzCo/1YoFKKLw5uPzCnHYRiGoihF2Q1COY5wOPwf//Eff/Znf0aVuh6PJxQKiaKYzWbb2trcbndFRcXCnh0AAMCSufPOOx955BGXy0VphVAoRAFDKBRKpVJutzsSiYyNjYmiSF0n8vk8rZBCstnsk08+6fF4aFItv/86MyOdnZ2pVMrn85WsHq2urq6urqZJsj6f7/Tp05lMZvONN0bq6yWvV5QkoZA7sN9Ib1iWbVu2TTkOXdOyqVRqfPwvb711sa8VY+yqq656+eWXDcNIp9MulysUCtGBUf0LY4ymtZ6zvQj1HVNVVdf1PXv2bN26dXR09OKLLy7ZZ40xRsvY09qxC7IwLQDMHpaJBVgAtm3TumWZTCaZTFZXV/v9fupqPjQ0RD0yxsbGFEUZHh7mM1D4uiTU/Jx2tW/fvqLOo3aBx+MpLy+vqamJRqMej8fj8dAGlPiwbdvn87373e9e+tOfwVVXXfXZz36WMeacsCMIAl/ofpZL0FFdKK0Yxxi7fcqwTz6fp6taX1//jW98gy9zq2ka/Sxqamra2tqoQyoAAMAKdccdd9Aqqul0enBwsKqqKhgMapoWCoUkSaKGXB6PJ5FIUNtLetXExAQlLHw+H63vLggCX1j9uuuu47GHIAiJRKK+vn6GDlZ0+x4dHVUUpaqqSk+n3YUF196YvWLbrJDfMA3DoqVhdV3XNCWfX1tbu72lZdGvFGOf+9znKDZQFCWbzdq2HQwGqXCDhltouVlN06ZLQ1iWpWkabZbL5Wzb/pM/+RPGWFVV1VNPPTXDW9Ma9j6fj1arBYAlgwQHwAL4wAc+cNttt+VyuWw2Ozo62tfXxxjLZrM0xJFIJMrKyizLovoL/nmelkDj4ydHjhzhO3S73bQKPUdTW03TpNoEqji1LEuW5bKysrVr1zY1Na1du/YCbDZBCQ7LsrLZrK7roVCIRooox0Er3s2Q5qAT5+ve27a9efPmogoOCuMqKircbndVVdW2bdt+97vf0c9iZGQkkUjYth2JRMrLy0dHR6ljGQAAwEp0xx13vP/975dlOZvNJpPJgYGBdDrt8Xho+VhaEtXj8ZSVlVEnciLL8sTEhMvlSiaTgUDA5XIVdcKiklLnI7FYrKmpibpoTaUoSjqdpmeD1dWuyWud2NR9wzQt07QtS9c0yzTlbFbOZLLJ5O1LOGXjM5/5DH1DUQeVvTDGJEmiURBKc2QyGcp08G7olNfI5XK5XI5mIodCoTVr1vAI5KqrrpqhLDSfz7e2tgaDQVVVl+A0AYBDggNgYdxxxx2MMVmW0+k0LfMRjUapFxfd/iORSCQSCYVCvDqDl29QTJBKpZ577rmJiYlNmzYJghAIBOgzv+1gmiati6YoCt10y8rKamtr6S327du3XKc/M8px6LqezWZp4Riv10vr0tGUEzod+p5iCwov6PFsNktBhmVZbrebVnXhEokEtfOorKysrKysqKjYsWPHhg0bXn/9dWpmLstyX1/fyMiIKIrl5eXd3d2UgQIAAFiJ7rjjDupvlclkOjs7KWERj8edC6k4HT58WFXV6upqKq+gBlWMMdu2nUUcb9ZfMMYKS6KGw+GGhobKykpaoYzvk9pdMcYmJiZCtbUul8vt7GfB56eYpqYouqapimLoej6bXVNZuWvKPNPF89nPfraqqooVBloURbEsi+aqSJKkqmoul6O5JzTiQtUxuVyOusXTg7ZtBwIBWZZpcRZSWVk5NDQ0PDxc8n1HR0ej0ejExMS8O6QCwPwgwQGwYD796U8HAoF8Pn/mzJmJiYlkMklZf8YYv+VPTEzw5et5H3IKKag88tSpU7IsB4PBaDRK80L5YmaO2ax2OBwuLy/fsWNHfX097VmSpMVePGXePvvZz1KOQ1XVdDpNOY5wOBwOhzVN46kNqtFwhhcUW1DayOv1er3eK664Yt26dXzPlN1QVfXEiRMTExPZbLapqenIkSMPPvhgS0uL3++3bXt4eJgajqZSKcMwqKZm+S4GAADA+fr0pz+9c+dOj8eTTCbPnj3b1dVVXl4ej8cnJiZ4yUAymezu7j558mRdXR3lJijScM6Q7e7u7u3t5bvl0YhzcMWyLEmSysrKIpFIMBj0+XzUBCSdTvt8vt1XXeWm7IbLxRzdNyzTpCVjTdO0DEPN55Pj44nR0dksnrKwbrjhhqamJsaYZVmZTCaXy5mmSWMtVEtLE1h4UoMvhJdOp9PpNGOM1mW76667aD/cli1bnFePZLPZwcFBuuBUgrpUJwoAjKHJKMAC6urquuSSS8bHx0+fPj0wMEArm8TjcY/HE41GaVU2vr5pMplkjAUCARp4YY4kSDwepy0Nw6ARBhptoIIOvqC908jIyN/93d8t2ZnOw2c/+9mXXnpp//79uq6nUikKLFwuF62KQm1HqUCDNyezLEvXddM0fT5fRUWFpmmXXXbZtddey/fJazcovHC5XNu2bTty5EhbW9snP/nJgwcPXnLJJYwxr9c7NjZGLVH6+vrq6upee+21RCKxd+/e5boaAAAA5+Oyyy771a9+dfnllzPGxsfHx8fHh4eH169fTx/LE4lENBp1uVy0FltZWVkymaQwwzmRhP7Z29srCMLq1auvu+66Z555JpPJUJ8vZ4KDT9wwDEPTNJoOQwWVliwLbrfL7WaFSIbXbliWZei6ZVlyPq+rqmUYt15//Z4lr2jYtWsXBVqdnZ1UParreiAQkCQpGAzquq7ruiRJuq7TTFiPx6NpWjAYpLVgTdPMZDL33nuvc3yFPProo1dcccXAwEBtbS1jLJfLdXd307hULBajTuc7d+5c4vMFeJtDggNgwXzgAx/45Cc/2dzcTAu1jo+Pj4yMWJa1evVq0zRPnz7t8Xj4sEk0Gs1kMmVlZc7shiAIpmnSJ3xawo1WWuHLjvAKDuf7TkxMbNiwYVlOeU5+8Ytf3Hrrrfv376d+5l6vl/I7NEOVchlU8MIYo+iKQgTLsvL5/JVXXlmU3WCM8TXtampqmpqa4vF4e3v7Rz7yEUVRfD4f31U4HI7H4+FweN26dZqmeTweqs4FAABYod773ve+8sorgiBUVlZWVVXR0IjH48lkMpFIJJvNZrPZmpqa2tra4eFhHmyYpsnrRqkTB2Ost7c3lUpVVVVJkkQFGqxQzWFNRrNKY7EYb18qRiK02CrPbjDbNgvZDdMwdEUxNE3O5ydGR+9aksVTitx3332f+MQnHnjggaeeeoo6g9J8WEmSKNiIRqPO5iO8hsU0zWw2u2rVKqpCnaqqqioajfb19bW3t1M/0draWr6r8fHxliXppQoATkhwACykO++889VXX2WMCYJQVVVVXV1NWYne3l6KDETxzV8627bHxsZCoVBlZSU9UtRok26xqqrSeAvt1jAMZ4JjcHCQMXb//fcv+rkthF/84hdbtmyJx+O07oymaRReSJJEmQ6+Je85QpWie/fuve666/izlN2QJKmzs5MxVlNTs27dung8/vLLL3/gAx+gog9+qXmZzPDwcDAYTKVSkUjk0Ucfvfrqq5f27AEAABbMZZdd9oc//IFWo6c4weVynTp1imZVMMYou8EYkySJhk8YY7xulDH2Zk9Q206lUvl8PhaLuVwuVVWpQRh9aDcMw+12m6ZJE1UCgYDzMKRVqxhjb1RfUm9R27Yty7Ys0zBMw9A0Tcnn0xMT73vnO5fy+jhddNFFuq7v27evqanpqaeeolIOTdM0TaPrxnusUohlGAbVrVx//fU33nhjyX2Oj4/v2rXrhz/8oSAImzdv5qEaGR0d9Xq9RVNaAGAJIMEBsJAuvfTSV199lScj6GZ5/PjxVCrFGOMTVVihZEPX9UwmEw6HfT6fM23Bv6d6DZfLRTNTbNvWdZ0WFtE0bXx8vL+////7//6/pT/Tefvc5z73y1/+cnh4uLOzk6bmKopC4QWfn0LJIMaYYRiNjY033nhjc3Mz34Ou652dnZs2baLshmmaDQ0N4+Pjhw8f/uM//mNWuLYU1THGaAmbQCBQVVU1PDw8Ojra0tKCObEAALDS7du37+DBgzNkN7LZbE9PT0VFBf/0Tr0zysrKnOu4sUJxRyaToV3RKqf0OE1XKTlDdkIUG6JR6r7BGLMt643KB9M0DENXVV1VDVXNZ7PramrunbLE+5LRNO348eM7duxoamp64IEHOjs7Kc3BGKOQw9mflWKwG264wbbtqdmNbDYbCoUSicShQ4duuOGGrVu3UqzS39/Pt0kmk6ZpvuMd7+ChCAAsGSQ4ABbYZZdddvDgQYoPUqnUsWPH+FPUb5zjHUbHx8d9Pl8gEPD7/cxRG8m/8mkpNKRASYF8Pp9Op/1+Py14tlLcf//9Lpfr6NGjN9xwwxNPPCEIQmdnJ4UXtFY8T+5MF1tQ4y6KS8rLy1evXp1KpU6ePMlLNiiGi8VigiBUV1fTMJQoiqFQqKamhkKQXC63ZKcMAACwGC699NLHHnustrbW5XJlMpmp2Y2Ojo6iRWHT6TSNKJSXlzsTHHyGLG9ESm0pitqcO989oWn1F1/sXBqWMWbZtmEYtmUZmmaZpirL+VxOzmb3XH75El2UUj7ykY/s3bt3+/btdKiU5mCMdXZ2dnZ2nj17lj9O299www3T7ers2bOjo6PXXHPNmjVrzpw5wxg7deqUruu8CnVkZIQxdtNNNxUt+gYASwMJDoAFdskllzz55JOVlZXUuIs/3tjYSJNNeDzhLPSgbMj4+Hh5eTmt/UHb8AQHKwwy8KLKbDY7Ojq6fv36pT7D83bvvfd+//vfP3r06F/8xV/QI5StYIx1dHRQeOEs2XCiYIu+z+VymzZtymazZ86ccbvdV199NQ/LhoeH6+vrq6qqqLaWqmAkSQqFQrt3787n85RLAgAAWNGuuOKKtrY2WpuMWpJLksSzGw0NDdTPmzFG6f7y8vJUKpXNZj0eD60xzxxrprBC4CEIgq7r1PybFeo7WGGqbCqVOnPmzOabb3a73QIFM3xlWNO0bVvXNF3T8pmMoevZiQlfMFjV0LBMV+gNH/rQh1pbW7dv3+58sKmpqampad++fbPcSWtr67Fjx7Zv397b21tZWel2u0VR3LRpUzqdzuVy1dXVXV1dgiC8973vRXYDYLkgwQGw8C6++OKenh7btoPBYC6Xi0aj9fX1+Xx+6gL1NIpCCY6ysjJd18fHxwVBiMViRZ/A+eAJfWLP5/OJRIKvEbvi3HvvvQ8++GBra+u2bduYY8xk5tmqzuxGNBptbGxMJpOjo6Mul2vPnj2UBqKYrKqqKhgM8rm1pmlSYCdJUiQSYYxt3rx5cc8QAABg8f3RH/2RJElnzpxJp9Mej4dWmh8YGIjH4/X19WVlZWNjY86+2nxYJZ/PU3ONWCzGn3XOkKXGYby40jAM0zRVVc3n8+Pj4/U7d9Y2N7+R3XC5+IIrtH4KtRc1DCObSuUymSvf/e4zvb1Xbdq0tNdmkvvvv//666/ftm2bs25lllpbWxljo6Oj1dXVn/70p03TrK6upk6lbW1tiqK8+uqrH/3oR1VVfd/73ofUBsDyQoIDYOHdeOON//RP/0QTUkRR9Pl81FCTl2/QV8pusEKXL0EQ/H6/3++nVMj4+DhlPag9B4UaNKmVFmxXFKW6upoxthKLOBhj991334MPPnj06NGi4ZTpDA4O8oTOyMhIWVmZqqpjY2O8m4nb7Xa73QMDA+Fw2O/38ym1NJeYd4yXJGlkZAQdRgEA4K3huuuu6+rq6uvrY4yJopjL5QKBwM6dO91udyKR4DEGK0zhZIxRAw63260oSjwer6ioYKVmyNJy9ZTdoCEWTdNyuZwrFNp49dW0E5fLxWyb8WEYXafshirLhqapshyKRuvXrTv6wgvLdX1+/etft7a2Wpa1du3a48ePzzLqILxko6am5sYbb6yrq2OMmaZ59uzZ9vb2bDabSqUsy/r7v/97usLIbgAsO9e5NwGAudu+fXtPT088HjdNM5lMTkxMKIrinJ/CHD04RFGkJdYYY7Zte71ej8dTXl4eiUTy+Xwul0ulUrz7Bg2euFyu1atXZ7PZ3bt3L99Znq/77rtv586dzjYl0+np6eHZjcHBwaamJl3Xx8bG6JH169fTyBKtfuf1ekOhEP2TAjL6hjYeHh7OZrPDw8OLdFIAAABL7CMf+cjq1atpbfXy8vLy8nJafF3XdefSHowxymtQayoq3/B6vX19fX19ffl8vijHQakNXdfpTqrrOhWQrr7oIlehLzjjHToMwzJNWjzF0HVdVVVZTo2Pq7Ksa5p38torS6O9vf3Tn/70oUOHamtr6+vrN23adPz4cWdP9+mMjIy0trb+8Ic/ZIzdfffdO3bsqK6urqure+KJJ3p7e1944YXe3l4aMrnxxhsvuugiHt2dOnVqcU8JAM4FCQ6ARfGud73rne98pyRJ5eXltEw6b4FZtMaKc2ilaBKsbdt8aTfKdKiqahgGrXuqKEp9ff299967jKd5/u67775du3YdP358hm1OnjxJVTD5fL6/v7+ystIwDFmWee9Vakqi6/rAwMDq1avLysr4ZaRtaFjJtu2hoaGRkZH169ebpjnzmwIAAKwgLS0tkiSFw2HKLei6TjfHqZGGc1lZl8vl9/tpMsv4+PjAwIAsy2xyjoOvM6KqaiaTqd62rWrdOsHlEqi9KG1pWVZhIq1pGJqqKrKcTaVESQqVlT31k5+IktRW6Le1NNrb27/+9a9v3ry5oaEhkUh0dHR84AMfuOWWW0re/ScmJrLZrK7rra2tTz31FDUK/dM//dNdu3bRKrB1dXUPPvhgWVnZwMAAVYy+853vvO6667xer3MG0NmzZ5fuDAGgFCQ4ABbLe97zHrfbXVNTw2sHiqao8FEU50L0vJMoc5SS8sSHZVm0iiq14Xj/+9+/bKe3cO69994dO3YcO3as5KDKoUOHBEFQVTWVStH0V8ZYNpulkhbGGI1TdXR0mKbZ1NQUCASorQkVvDi7vg8PD4+NjW3dujUQCFRUVPT09Bw5cmQJTxQAAGCx3HLLLddcc00ikfD5fJTayOVyzs/ehFeP0r2Slx54vd7q6uqKigpVVUdGRuLxON1neR0HdTdngcCGK698Y2YKY8yxwMob02h1Xdc0JZdTcrn44GCsutq2bWZZh5977mRHx1JekOeee27Hjh2yLHd1dSmK8pd/+ZeCINxyyy0nTpwoWvKWBj+SyaSqqrFYbN++fdu2baOZLHQF2trahoeHqX+Hy+W66qqrrrnmGt68/JJLLqH90CTiP/zhD0t5mgBQBAkOgEV03XXXjY2Neb1eWliehxE8vBAEwev1OhMcfJl6ymJYBRRA8OBB1/VVq1bNaR7pDF5//fUjR4585zvfef311w8fPrwg+5yT++67b8eOHU8//XTREnSnT5+WZVnXdVmWR0ZGotGopmk034S+WpalKMqxY8dqamqqq6u9Xi9V0tLLeeEGbTkyMtLS0sIYoyVjKyoqent7X3/99aU/XwAAgAV32223XXLJJbIsi6KoaRpNaC0aWaHBFY5eWFQ6GgwGfT6fLMvZbDafz1ONpKqqjDGvabpcLrcovjFm48hu2JalKgp139A1Tc7lAuEw3YltxgRBCITDS3YpvvnNb2YyGcbYyMhIMBi88847KUejquof/dEfUdNQ8uijj3Z1ddm2ret6NpuNxWJU/1I0f5bXvFx66aX8Mvp8PlqJhpIdLpcrFotRQxMAWC5oMgqwiG677TbTNKm1lTPBwQrlG/Qg1XHQ41R04CzlcJZv0EKzsizH4/E///M/P8/D+8///M9wOPzv//7vVO/ACyguuuiiBx544KKLLjrP/c/J/fffv2vXrn/+53+mVl70YFlZ2YkTJ+iUGxsbGWOqqkqSxOf7MMYkSbr88sspnqDUBl1DepY6jDLGhoaGNmzYQE06aO5xMBisrq6m0o9LL710KU8WAABgMdxxxx2bN2/OZrOHDx/u7Oykz+R2YQ11/g2hl/CRADY500Hf8+EExpgoiquuuoqyG4y6b1gWrz41dN2i7IaqKrmcoeuVdXXOotS2rq6bLr98CS7Cv/zLvzDGwuGwoiher3ffvn2U9KGho1wu197e3tTUFI1GGWNNTU1jY2O0oIzH47Ftm8pFt2zZQsNOfLc7duzgsZzL5fL5fHV1dWVlZYODg4qimKZJfeVbW1vRahRgGQmzabQDAOfjn//5n0dHRz0eT1GlKN0L/X6/JEn0FC9M4F+Zo4sEjZ9YlpVMJvft23fPPffM+5Bee+21Q4cOffe736VFVfnj/A+Cbdsf/ehHH3jggXm/xfwcOXLkc5/73FVXXVVTU+P1ehljw8PDr7zyCsUKNELi8XioNdrIyMgNN9xAj4fDYYpLOMFhaGgoFovRaBUfhLEsS9O0RCIxMDCwd+/eVatWLfHJAgAALJIzZ85873vf83g8zo/oPGfh9/spLBEKc0yoMzd942xiRdEIFZCGm5pqd+50u910H7Wp9QY9q2lKPq8pSjaVyqXTYwMD+XTaFwyGolGX223oupLLjQ8PP/6DHyzGyR46dGhgYOC73/3u2rVrg8Hg6tWr6RRyudzGjRuDwWAgEJAkiS8E8/TTT585c+baa6+l8ZI//OEPzc3NXq9XFMXOzs6tW7dSmOEuNFLduHEjPULxw8DAQGNj46pVq4LBIM3fGRwc5NmTkZGRmpoaDJwALBdMUQFYdLfeeqsois425s4aUf4Un0/BAws2ub8XlSfk8/nm5ubzyW7853/+51/91V995zvfoY7o9CB/X/7NN7/5zW9+85vzP+15EQThIx/5yAsvvPD8889TfmdiYsK27a6uLlmWNU3LZDLDw8ODg4OHDh2i7AZdqFwul8vleKd35rh0zz33XDgctgvNz3jERumScDhcV1f39NNPL/GZAgAALB7nDBTmWJ+eKhmL2o46kxp0l6SBFvpG0zTDMKLr19dQCYPLJVBIUxhRMHVd0zRD11VZtkxTyeU8Pt/e227z+v3jw8Oaoti2zQRBlKQFP80HH3zw4MGD//qv//rKK6/s3r27ubm5urqajsrlchmGkU6nc7lcJpPJZDK0qmsmk8nlcvF4/PTp04yxkydP5nK53t7e4eFhXdebm5t50QovP6HvDxw4MDY2tnr16q1bt0qSlEgk4vF4NpulOhG6nh6PJxgMvvLKKwt+pgAwS5iiArDofvOb3zgjCVboHkoLmjojDOeSH/zlzoEU6i166623zvtgvvGNb/znf/4n1Yw46zWYo3yD+9a3vsUY++hHPzrvt5uTbDbr8Xj27Nnz7W9/+1/+5V9eeOGFrVu3VlVVnTp1KplMmqbp8Xhoy/vvv58xNjExQRc2GAxKkkRL4tGyu6wQzL3wwgu7du3i15NiO9u2qVSVSkxFUTQM48knn6SMCQAAwEr35JNP8jJGVmjyxRijWyQVI7DJa43xqSjOGbI0MBBdv768pYX6h9HiKTbvDkYjB6ZpGoauaUo+nxof37Brl23bm/bsOXHgQGp83Ov3i5LklqSTZ89uWb9+QU7wRz/60QsvvLBjx45f//rXmzdvrq6upoP/4Ac/mM/nTdN88sknY7FYf39/XV2d1+v1eDyU8lAUZevWrYZhnDhxYsuWLW1tbTT11e1200QVt9tNPd3T6bTL5briiisEQYhGo3fccUcoFKJuX7quW5aVz+dp5qxz7g9NXXnmmWfe+c53LsiZAsCcIMEBsOj4x3JCEYZlWaIo8lajfJSApzloY2fkQXWVTU1N8+4t+rWvfe0b3/iGKIoej8fZiXOGqWrf+ta3FinB0dvbK0lSKpVyuVyapsVisXw+7/P5aMTprrvu+vKXv/zss89ee+21zc3NfX19kiQxxkRRvPnmm3t7e6ntmdfrpeoMn89Hr6WXU5rjtdde27lzJ+/bSteZJiFTjoPayDPGKioq4vH48ePHt23bthgnCwAAsJS6urr8fj8fWaF7n6ZpkiT5fD5nXzCey3CGH86sh6esrHzTJt44zLmsPa2cQuvC6pqmynI2lXKLYqy6Op/NarJc1dDQ09amyrJpGMy2FyTB8fDDDz/66KOrV68OhULHjh3btm0bzSWhDIWiKB6PR1XVffv26br+1FNPjY6OhsNhGtqh3uSU6TBN8+TJk3V1dUNDQ1QHSqvDcp/73Ofo0jU0NESjUcprZDIZShJRzsgwDB5QMcaokUckEqHmowCw9JDgAFh0nZ2dFEywQnaDMeZ2u6nhdlGE4Rw2YY4ZsCSbzf71X//1/A7jlVde+frXv07DC4ZhTFe1MdU3v/nNBc9x9PT0vP7669u2baPL4vV6NU2jqcJ07jU1Nbfddtvw8PCTTz7p8XgoWKEJw88//zyVgPr9ft6mhL7huSTbtg8fPrxx40Zn+sYwDN5ijTFGL6Eck9frpYVjbdteqLVpAAAAlsXZs2elwnwQ5/opvO+GM01RFHjYjgXITNMUI5GaSy+lwg3nom+MMcs0DV23qb2oaSq5nCrLEyMjmy++2NA0XVHSExOp8XE6jOpAwCtJqYGBf/qnf3rPe96Tz+f37Nkz1/M6cuTI3//9369du3br1q2Uldi6dSsVb1K6geo0JUni1SsUP/T19VVXV+u6HgwGRVHcsmVLKBRyuVwnTpzw+/2hUIiqMNxut6qqn/vc5xRFEQSB9swYUxTF7Xbrui4IgqZpVIRLgVlR/3jqYu73+3/84x+Xl5dTf3QAWEpIcAAsrjNnzlClBivc+ehxKjGg8oGiCMM555M/S/0yGhsbd+zYMb8j+cpXvmJZlt/vF0XR+bH/nDmOr3/96wub4Dh48KDP56NaCdM0nUNJvLuqYRj19fXRaFRRlOeee45NzvVQgsa2bZrjw//p8/k8Ho/X6z158qTX66Xrxhjjy8RQiQdv0sEcPwifz1dZWdnT02NZ1s6dOxfwfAEAAJbSo48+6pwb65whS/dB3vyrCJu8kIorFKrYs0fyeKjgUXAkOOh+zGxb13VD1/OZjK6qaj6/qrm5orZWzuU0RdE1LTk2Rm/d0tAQDAZpMbgf/ehHyWTyu9/97vr168fGxv70T/9UVdXdu3cXncWpU6csy9q6dSt/RBRFr9cbCASCwWBTU1NfXx+fVEJnRLd7ehe6v7/jHe8wTXP//v2MMb/ff9lll3V1dZ08eXJ8fPzMmTMUXNGWgUAgFAqFQqGXX365vLw8Fov5/X6/3+9yubLZLA9CeDMvOiRKrPB/tre3Nzc3v/jii9dff30qlVqkny8AzAAJDoDFRTEBX4+Nvuq6TnNB+QzYqbNenZkOugGnUqm/+Iu/mN9hHDhw4LXXXrNtO5vNVlRUOFdOcd6YS5IWtCvY6dOnJUnyer2ZTCYSiVDowBjjQQN91TQtEAicOXPmiiuuyOfzr7766qpVq1KpFF0TaiZqGEY4HKbXZjIZmhBrmuapU6fC4XBjYyOFHdR0g+I8nuag0IcuOw3RuN1uaod+5swZy7KmRloAAAArQjAYpP4RzgQHr3GYPMuEJyveaFbFm2talhVdt06UJMHlcouiUOiV/maFqWWZhmGZpq6qlmVl0+nB7u7rbr9dkWVNUeRsNhWPb9248cTp04yx9q6uDY2N9O5dXV2iKB47duzgwYOWZT3xxBNer7e+vn7Hjh233Xabqqq7du16+umnf//735ummc/nGxsb3/e+92ma9pOf/MS2bZpdQmWwuq6LoujsnPrEE0/cdNNNdNPni6Zt3bp1YmLCMIyXXnopm80ODQ2NjY0FAgGadUKtuGitOkmSkskkDZaIokhDILQKLM1woYtQ1FWNMfbb3/62qalp06ZNpmnedNNNmUymtbV13oNSADBvSHAALK7HHnuMMeYMMgRBoLqDovET+sTu7NrNCr3NdV2XZXn16tXzXln93/7t32iOqCRJVL/ATZfdcFZdvvLKK5dddtn83tqpt7d3aGiorq6us7OT+pyzyVUblNqgbiO6rldXVw8PD+/YsSMajVIAxEMx5mi86kwDJZPJysrK2tpaGtWhC85HeFih+HbqsdGKNoFAoLa2trOz0zCMSy655PxPGQAAYIl1d3fz8QPn3ZwPutA/eWrDeWfk99lgS4u3vNwtii632zV5YgtlNyxaYEXXFVlW8nk1l1u/Y4ep60o+nx4fTycS//MjH9m2cSNj7Pjp0z/57W9fbmtzp9MdHR2SJOXzecYY714hy3JHR0cul6PHH330UY/HU1VVxduW/fKXvzRNMxwOr1u3Lp1OezyeysrKpqamTCbDb/F0l6eBDVaIuLq6us6ePWvbdnd3N43uDA0N+f1+WZYlSVq9evXJkydpBitdGZpBnM1m/X6/1+uVJMkwDAokaEKKc1E8xlh7e/uGDRsee+yxm2++mS4dbePxeMrLy1977bWLL754MX/UAFAMCQ6AxeX1euljNiu0e2CM2YUOl4ZhJBIJWZZ5R256lt+kecuMeDz+sY997HyOhJpvsSkZDWfo4+Tc7JzTWGbjF7/4xYYNG1atWpXL5Wguq6ZprDBYROkJntrQNE1VVUVRBgcHqVL0qquuam9vT6fTdmFiMM8HUd2H3+8fHR2l+a60ogr1+qJ3pzoOZ47D+U9nRBIKhUzT7O7ubmhoqKurO/8TBwAAWDIdHR08inB+pTbbFJOULN+wHbNlpZoaX0WFq5A4cPYLo+3ofk3pDL407PqdO9Pj49SMoy4SoewGY2zbxo0vPv30b15+2efzOZeoLzI8PDw8PLx9+/Zdu3ZR6QSNDzmHQ4LBYDQapUbjHo/H5/Ol02m34zgFQVBVtb+/3+PxtLa29vX1CYLQ3d1NZ0f9QRVFuf3222+//XbG2EMPPfTjH/+YwhLqwaGqai6Xo1ZflOPgw1TOTl6PPfbY+vXrqdvXzTffzArVHLy3VzweHxgYQIIDYIkhwQGwuDo6OqiNOS+eZIXMRTwen5iY4MkOUpRKoLIO27Yzmcy8yzdefvnlAwcO8A/zs3nJgmQ0yI9//GNJkqLR6KuvvnrxxRdrmkY9zKkHmGmaNDCiF1BqQ5Zl0zQVRYlEIul0WpKk8vLySy655MUXX5Rl2TlDmCc7ksnkpk2b6EGqOKVAjXqXskJsxFuRUTMOuv50DPSDoJ4gtm0///zzV1999apVqxbqUgAAACy2Rx991Plpn9i2TZ0mnFUYlGiYOkvFXVXla2iQPB63KPJeHpP6kpqmTUvDmqah62o+nxofb7noonw6reRyaj4/NjDw//vqV/khfeMb3/jOd75Dc0lKFlE6o47W1tY1a9asXr2ah0x2oWcW3dYlSero6HC5XOXl5T6fj0II2jndx7u7uzs7O3t6elKplKqqmUyGJtvecccdFABQaoPcc889P/jBD6gMhPYjy7LH4xkfHw8EAjRRhV8BKuI4fPiwpmnvete7mGP9Xf4sv1DNzc1dXV1YLxZgiSHBAbCIqMOoy4HPmBgcHNQ0jaZFeDweWrlNcKwXS+huTSUeX/nKV2655RahsOhpRUXFnBYh4/fg2Sja8vLLL5/9G3GvvPLKl7/85aampmg06vF4GhoaaJprOBzOZDKURKABE6rdoGETmuna3t7u8/kqKipM04zH47FYjHIfLS0t3d3d4+PjjDFaX5aumKZpW7ZsodDE5/PxBmPU7ZznOJijXoOSHYwxSiFRbEQ/II/HE41GGWNnzpxBggMAAFaQYDBIN1lW6PzFP4FTLWcikdA0jUYL+D1REASKWPz19d76eq/f75YkURRp/RTmyG6YzqVhVVVTlFQ87tI0OZk0dF3O5VITE3/rqDn9+te//o1vfIMaXRXVbkw3mjIyMrJmzZqpDUR4+iASieTz+Ugk4vV6Q6HQ6OgobzVqWdazzz7LGNM0bc2aNfF4XFGUP/mTP3n/+98/3RW7++67H374YRosUVVVFEVFUahZmMfj4bUkPT09zc3Nv/3tb9/1rnfxwRJ+bLZjDRpWGMqqqKgIhULn89MEgLlCggNgEVH+wjn6IQiCpmnj4+M0P4L6gdNkCjY5B0GfwOlxesrlcn360592u92f+cxnGGNDQ0PUDWvjxo21tbUzHMaBAwdo5RQeGcwJTSSZvQcffLClpeWRRx7xeDyXXXYZJRdkWabToR5duVyO9uzxeCRJop7niqIoisIYUxRlYGBAVdV169aVlZUJgnDxxRf//ve/z+fzqVTq9ttvb2pq+vSnP23btt/vtywrnU63tLTQa3kXUioQpXQSY4z/IJzBBx0wL+XglR2CINDs5fHxcYy9AADACtLT0+P3+xljvKM2K+Qm4vF4IpHg1Ry8iRVvuS1VV7urq9/ou+FYGvbNWS00q9QwVEWxTFPJ55V8PptOr/L7Y5mMJQijqdS7rrhi+6ZNdDCvvvoqLVHv8Xh0XbcdC7XM4ODBg6ZpXnHFFc6N+TeCIGzcuPHgwYPBYJBattP6LDTVVxTFuro6WZY1TUulUhMTE+973/tmyG4wxu65556HHnqI5u/wbqOqqiYSCVqd7cCBA01NTevXr9d1/cYbb6TL4IypLMs6c+bM+vXrhcJStdTLw+PxHDt2DC29AJYSEhwAi+ixxx7jk1MozjAMY2JighUGUnhef2rtBiv0xxIEIZVKiaLY1dUVCoXS6fRXvvIVGkKxLOuSSy7p6Oh45zvf2dfXF4lESq5veuDAAboT0zLvc51+QhHGbPzgBz94/PHHq6urjx075na7qfaB5qFQFsPlctE3pmkmEglFUSjBYdu2YRjUmyMSiQwPD1NB6fj4uNfrZYypqjo0NHTLLbfceuut9F7/8i//8tBDD1GlaE1NTSKRMAyDZszSm2YyGVVV/X4/dQijolZh8lRku7COLJ/DwhjLZDJUViOKYkVFRTwef/rpp6+77ro5XTQAAICl19HRwUtHBceaKbIsJxIJqpqkxUGo5pE5ig7MqqpAba3k9Xq83uKlYan1BuU3TNO0LNuyVFmmBWLNbFb0eAzDSHd3169efcfNNzPGzpw5853vfOeRRx5xDtWwWc+BdbvdztQGfe8cLrrooou6u7tpObZwOJxKpahZRiaToWZe+Xw+mUx+9rOfdS40O5277777hz/8IQUkqqq63W7qofbaa681NDRs2bIlHA7TNBYKqChJ5Dyj9evX8+95mBEMBiORyP79+6+66qo5/iQBYJ6Q4ABYRHwtWH4/pmXb6NlwOMwjjKLFUxhj/BM4Y0yW5VgsdurUKdqJaZqxWIwGB3p6evbu3dvR0ZHNZkdGRvL5vCRJ69evnzp7hc8OXYwz/elPf/rYY4/V1NQ0NDT09fU1NzdXVFTQKVDYRCNFlNYRRfGP/uiPfv/732uals1mTdOkbMLVV189Ojo6Pj7e29vrdrtpRfq+vj63253P5//rv/7L+Y67du2ipiSHDx/+4Q9/2N3dTdNV+DnymcZUOULdRmkqirOOlEZa6DhzuVw8HldVVdM0asZRWVkZiUSSyeRTTz21b9++xbh0AAAAC6UowUGy2SwNrjhLR3ljUSopTUlSJBr1BgIej8fj8wmFVUUEQWCCYFPz0cLiKZZh6Jqm63omkRjr768MhahaUxTFPY2NjLGPf/zj4+PjNTU1jDHLsvgk3NmfyP79+y+66CLnqAyvmKBvJEmKx+OiKNbX18uyHAqFNE3L5XJUEJrP51etWnX//ffPJrvBGLv33nu/973vaZpG81U1Tevr66utraX5qjTowktBmaMhSNGiKhwdpMvlikQiwWBw9icOAOcJCQ6ARdTR0RGJRFhhmdh0Ok0ftm3bDgaDoVCIFvugjfkETlbIbjDGPB6Pbdv5fH7Dhg2jo6MUoGSz2d27d9PEir6+vkceeYTWN9U0rb29PRwOHzt2bNWqVTfeeOPHP/5xxhjvMGqaJhVEzMnJkydn3uDIkSOPPPLI+vXrKQ4QBCEQCPB5N3SDp9kfP/jBD+666y6KHm644YannnqKjued73zn+Pj4K6+8omna0NAQTR6+8cYb3//+97e2tp46deq9733vdO++e/fu3bt3f/KTn+zq6tJ1ndp2hMNhunSmaZqm6fP5qBMHhUrOSIuiE8MwxsfHE4kETbWlPVPZyNjYWFVVlcvlamtra2lpmevVAwAAWDI9PT28aJS+UiED/7xNH7bpVshrN5Km6auo8IVCkscjFlIVLmf5RmFUwNB1TVU1VTU0Tc3ndVWtb2pa1dQUb2uzMhmXy/WLX/zi8ccfZ4x5vd4nn3ySMcZ7fs/pRHj1JX+EdxWhBycmJmiOKo1n0LySfD6fz+ff/e53y7J85513zukd77vvvoceeigYDFL7Vb/fT/v0eDyZTMbn8/FL6owo+PydqQNI9IPweDzHjx+fd594AJgrJDgAFgt1GOXTX6kugJ7yeDyRSIQyFM7yDT5SUdS8yuv1RiIRWZbz+Tx1mlBVtaysTJZlv99P4zCUNZBlWZbl0dHR06dP79+/nzG2du1afuulT/W0B2edJx2Vc2zEeSK2bX/84x//6le/yhh7+OGHQ6HQoUOHPvCBD8iyTDdsqiWht6DToRVJqDKCV3JSYSff3rKs66+/vrOz0zCM/fv3p1KpoaEhXdcTiYRlWc3NzTRjdseOHTt27Djn1f63f/u37373u7/85S8Nw6ioqDAMIxKJ2IUVUmguDF1VOgY6YFaYeDwxMZHJZOj6SJIUDAYpM0KXYnx8PBgMDgwM2La9efPm8/5PAwAAYFHQrA1+f9d1PZlM8sR9OBzma4XQXBOXy5XTdcXjiUWjkiR5vF6X2+2m3qKFqODN7humaZqmZZqaosjZrJLLjQ0MXHz99XIuZ4XD/SMjPsOgiaKMMUVRcrmcy+VSFCUUCs2pfIMxRr0w+D95oQTdqROJxKFDhwRB8Hg8uVyOhoKy2ewtt9zS1NRUcrruOd13333/7//9P13XqRjENE3qdKYoSjqdDgaDkiRRxy66gLy5Cb28KMdB39NUl2g0+sorr1x22WXzOCoAmCskOAAWi3PuK916eazg9/tpxgT/zO9cIJaGLEhtbe3ExITX66XF2KlbOGUQMplMKpXq6enZsmXLF77whY9//OOCINAIgyAIkUikpqYmEomcOnWKTS4JcValTu3dxRwJDtrVqlWr1q5d+4tf/CIajba2tlKc9P3vf19RlJdeeknX9ePHjweDwWQy6ff7o9FofX19Pp83DINKZGlOLCuUsVAEcObMGdM0z549m0qlaGQpHo/TsjJUTzHXgRfG2Ic+9CHbtqkRemVlJV1JqiWhq60oSjQapdwKzaSlKzM+Pi7LMu2EDpUqeOlHRpspiqKqKuWhtmzZMtdjAwAAWGxnz56lthq8rCCVSvHP4eFw2O/3G4bBS0fJRC4XraqSPJ5AOEwNOHiHUdqAogXK+5uGYRWWdk9PTNSsWWNZlpzLJUZHPZZFd1tC650xxjweD8+wzImzSZYzSsnn816v93/9r//1yCOP9Pb2WpaVyWRuvfXW2267bR7v4vTRj370Zz/7GXUEoziBuqGrqhqPx6lA1eVyUXEHhTfOvEZRKGUXmrn6/f79+/cjwQGwNJDgAFgsHR0dNBWCKgiouoGKQv1+P4UgfJYsc9wXeeGAJEnRaFSW5Y0bN5aVlcVisa1bt9KH84mJiSNHjsRisTVr1lBNwb59+1544YVIJHLy5Mnq6up169bl83mPxxOLxXgVCWOMqiUVRfH5fPQIL+goeRbUx1QQhMOHD/v9/vLycloJhe7cNMVm06ZNgiBQY3aqSfH7/ZlMhrbkRRPU7aK9vb21tdXlcg0MDPT399OzvNrTsixZlr/whS/MbzLIhz/84d27d3/mM58xTZOOzbZtCkds2/b5fJqm0Q+CF74mEglKZNDF4T8OURTLysqoURkfCstkMr29vT6fr6mpaR6HBwAAsHj44vR0z0qlUjyi8Pl84XBYKCzQxltIpBVFikZDsZjH53O73S763+SlYZltm4Zh6rppGLS+iK6qmYkJy7Yb1q9PxuO5VEpIpfzipI8VPMFRcvrGOTU0NNiO5Vd5GKOq6sTExN13393S0rJz584TJ06cOnVq5kVSZo9ajbpcro0bN1KFqaZp1HPUNM1cLqcoyuDgIMVdzgGqkifoLOKor6/v7OxE8ACwBJDgAFgsZ8+e5ZkLKmegxynaoOpQ3sCct72kXl+0WSAQkCRp+/btkUjE5/O9+uqrtIfy8vKxsbFIJKKqqs/ny2azx48fp+LM2traK664gnqAsymDCZIk0fc8u1H0/VR0L1+7dm0sFqO+6zwFwAprstLXmpqa9vZ2WhqGlkajbu1Uyclbfra2tg4ODg4ODvIen4IgGIZBi7m+973vfd/73nc+l3337t1/+MMfPvWpT3V3d+u6TovGUcmMs0yGamdosi49TgEfYYWmaMFgkFej0DXUNK2rq8vtdjc2Np7PcQIAACys7u5uutvS3YrXKlJdJ8UAhmHwhty2bacZC5WVebxer9/vliSXo3kH3enfuMtblm3bhqZZliVnMrQ6bENzsyrLpq7n4/GyQo0GTWhljK1du5bXb87jXGi5d1aoh6VDolGQ8vJyPgqydevWWbYRnaW77rrrpz/96enTp6mIw+VyqaoqiqKiKKIoDgwMrF27lkaJinqClMxxUBGHJEk1NTXJZHIBjxMApoMEB8BioZpMuiny254oiolEoq6ubmrnC8ZYIBCgdpiapr3++uurV68OBoOyLFdXV2cymXXr1iUSifr6+mAw2NDQ0NnZOTg4WFtbOzw8/OSTT0qStHnzZruwfCw/DEoc0LsU9euaDZ/Pt2nTJqrDfCPimdKhQyiszxIMBtPpNFVMRCKR06dP19XVUREHBVIDAwNU2VpfXz86OkrTa2+99dZNmzYtbG+LL3/5y9/73vd+8Ytf0NXg4z90nLIsR6NRVVWz2SyfNUPlNjzHQfEfTZ2VZVlRFD4mJstye3u7y+VavXr1Ah4zAADA+aDAg+5rlL6nxynrIUkS3Xb5450jI1Yk4vP7JY/HLYqiJLndbrcoMkFgju4b1HyD5rZoimJZlpzNut1uIT2U7j2VO/70+z/6D+/9wIedR3LgwAFe/Khp2jx6cNDoCO2B7r+U3RgaGvqzP/uzBbhY07j77rt/8IMf8Ds+rahC4zQUJ2SzWUpbELpEPBfj3JVQWG+FxrSOHDmyZ8+exTtyACBIcAAsFlpChTIO/J5H8QHdp3Vd1zSNpsWuX7+eghLDMAYHBycmJrZv3x4OhysrK7u7u6n7gyAI4XA4nU6PjY2l0+lcLpfJZFRVlWW5qqpK13XbsR47K9xZg8Egz0rQMMJccxxer5eHKXzPfLyC5w4EQWhubj58+HA0GhVF0ePx1NfXa5pGQ0a9vb2madbU1NBZp1IpWZbf//73z7A8ynm6//77GWM/+9nPVFWl1VVolgpdBFmWadlaVrhQNGbFJw3xNIfP56NVbGVZ5tfBMIzjx4/39/dfccUVi3T8AAAAc9LV1RWNRt1udyaTYYW7myiKmqYFAgEqXaSswRsNtnW9JhTyBYOix+MWRfofv9/blOCwCgxDp8kpyWQyHned/O2InqwIi7roeux3v3/qxcO8doM4Y4Z5nMs73vEOZ9GoaZqKooyMjFxzzTXbt28/zws1szvvvPMnP/kJz6rouk6tymmUKJFI+Hw+CufokpacpWJPXv/F6/WWlZW99NJLV1555aIePAAgwQGwKE6fPk1rwvOVUxhjoijSOq+6rk/8/9u78yi56jJ//J+739qX7q7uTnrLvnV2yCYCGtCZEWRxIcQREAWFEFRUnN/P8Xw9znyPI6CgCeKPgBKIQgQHJDDiIANhCCELASF7upP0kt7X6q7lVt3l98dDX2+qk04v1Usl79fx5PRS260Y7qfe9/k8T0dHfn4+LUHq6+tPnDgxffr0srKynp6e5ubm+vr6vLy8RCIRjUZVVd2/f//kyZM1TdM0raenp7e3t7GxsbCwsKioSNd1n89HRQrOkyt9nU6n9+zZ07/sYvA0TctIN5ijQSmtfOwb8Dw/derU9vZ2l8vldruDweDJkycpNaDJJolEIp1OJxKJ7u7u66+/fvTSDXLLLbeYpvnMM8/Q1SfKOJwvm/WNr6Pgw65SsWe+0OKGOrzSO+8suO3p6XnvvfcWL148qkcBAABwTtXV1dRonEoXOcdmUuo/5bw4IQjCydbWcFGR1+8XRZEqOHhBSHd1Bd1uSZabjx+fX1nJSxLHcXo6bRiGJkl/OXxYUFUtFvP0nFx/pWvXUb29V9fSaY0xxhhNpidHjx5lfds3nPtDB482irK+fb6xWKy5uXnVqlXXXXddFt6sAd18882CIDz33HN0PYM6iKVSqWQyKQiCqqqUd0hU8CIIrG9dZNeEZmwQpuFxHo+nubl5tF88AAxnUxwAnJPdrpJ2iLC+YgfKI2hseywW8/v9Pp+vrKysuLi4ubk5Ho9TuUE8Hu/p6YnFYsXFxZFIxO/379+/ny4XuFyuYDA4bdo0GlfmnC1vn1/p43c6na6rq2tpabEDiGGUb2SMXHGWqjo7sduFDwUFBTzP9/b2appmGEZRUZGqqlRmEovFent7u7q62tvbV69ePQZrFMbYrbfe+tOf/rSkpKStra2lpaWjo4P2m9h/L6xv/479V2Z3UbU7z1PpR2Fhof322rdvb2/fv3//GBwIAADAAI4dO0ZnKOeVCUmSaAg6Y4wuk1Brqqb29rZ02hcKSbKsuFwejvNwXE91NXfypNTZGdS0JTNn+njeLwgBUQxIkl8Ug7Jc9cYbTYcO9USjleKJD2vihsk4xjjGvnn33YyxcDjM8/zixYtnzZpF/blpCcFxHE0io2UDrVvs7mNnQ0fBGEulUp2dnXV1dStWrBiblQM9O9XYMsaofiWVSlHDUWp5Rj3IaUVk777pn26wvlIOezrb2Lx+gAsZKjgARkVVVZVpmk1NTVTBSD20NU0LhUIej4eqHJ1z2qil6MmTJ71eb3l5eUFBQTQapR5aVF8wbdo02ttCp1K6OGN3QXc+NS0aqN23oih244zhFXFMmTIlY99sxrrE3spBH/gty6LNMlQTQTkIrQko5vinf/qn3t7eL3zhC8N4McOzePHixYsX33PPPTU1NRTQhEIhqhelA7Gn2dt1KM69tfYhy7I8e/bstra2aDRqv58cx7W0tOzfv7+8vNzn843ZQQEAADjV1dXRsDZngk+nYGr7TZ2/FUWJRqM+r/ern/ykvTxoa2trrq1tO3GiqLLS7XbTrDc6A7a3t1OX8XQ6vXz5ctM0Y62HQ14P02KewhmCUhpvan/wkSdmz54diURisRhNfI9Go6zvrCr2TVdxvjCbfeZljuYguq4XFhZ2dnZyHNfR0dHc3Lx+/foFCxaM9nto++pXvyrL8rPPPksxDV3XoUMTRTEejzc1NZWVldEOVucyzM5EGGOJRCKVSsXjcVppqKoaCoXefffdpUuXjtmBAFyAEHAAjIoTJ060t7e3tbVdffXV5eXllmXt2rUrEomcPHmSORqLOk+KtI2TijhEUQyHw52dnc6ai4zLHc5eG1bfKFb7oRKJhPNCAVUciOKQ/8k7l0rOaIMuU9BT2204dF2vr68/deoUdUWlfmbJZDKZTMbjcdoV/OqrrzLG1q5dO9RXMkI///nPn3zyyT/+8Y80PtYwDI/HQ2spXdddLhfn6NNOX9hlKbqua5omSZLb7ZZlubu7OxwOOzOOtra23t7eBQsWuN3uMT4uAAAAxhi1wKR6Da5v2DzNahVFMRqNNjc3T58+XVXV9vb2eTNn7tixY+HChXl5eV1dXTU1NXV1dVOmTPF4PFSIIQgCLSRcLld9fb3L5dJ1feHChbFYLD1lCmOssbExFosxi5UvWTEpnWaM9fb20iuxLKu9vd1OKwaeM8L6SiScq5pIJEKPT7NUVFXdtGnT6L59p9uwYcOXv/zlp556igbE0gqH2o3Tmzl58mSq6aC33bmuMwyjo6ODVj50OLQZtru72+PxfPDBBwg4AEYVAg6AUVFdXT158uSVK1cGAgHDMDo7O/Py8lKplN/vpwKHjDoIOzWg8yhjjLZ9Oj9FO8/99s8ztrZSAUUsFovFYvRQVHpAqwehb4rb4NXX11O9if0K7V85N/TSub+tre3kyZMUr4iiKAhCLBbr7u5WVdXlcjHG8vLy6L7OnbrnlNG3bNhuuukm0zSfffbZZDJJHdfs19Pb26uqKm33td/2jMEx9Nc3ZcqU/Pz8xsZG6jnK+lZsmqZ98MEHyDgAAGDsHTt2rLq6uqOjg0om6eRFjb3z8/P9fr+u6xUVFZZlJRKJUCjU1NRUUlKSTqffffddl8tFuX9LS4umaV1dXaWlpV6vl1YRvb29ra2tbrc7Ho8fOHDAMIwpU6akUqlEIpGfn29ZVjKZzLjiUldX56wbtcskbTTJ3uY8mRKPx9PW1qaq6nidUmmVEgqFYrEYFc/S1Q5qlM7zfHd3N/XnSiaTHo+HrlFRtBGNRqnWw1kcSkcXj8eDweA777yzYsWKcTkugAsBAg6A7Dty5EheXl5HR4csy7FYLD8/n8as9vb2Up2Fs7mDfS/O0Q9M13UqerQvejj3Sth9PelXzs2fyWSyvb09Go1SnCEIQkNDg8/nE/om2w91Tht1+mCOCMZ+tZZjLhqFGq2trX6/v7u7m2pT6fQfDAaH/1Yyxs6Vhgwp/rjlllsWLVr0/e9/n158MBikd4YxRldmvF4v5RrUZ57+pMM0TTMejyuKEg6HTdNsbGx0dpDlOC6dTu/evdvn802bNm3kRw0AADBIoij29PSoqnrVVVeFQiFFUQzDaG5urqqqot0ljDG72JNqMKnVVywWmzZt2vHjx6PRKDXOXLBgAXWYMgwjkUg0NzcrikLn93nz5tFKRhAEun7jfA32WqWsrMz+iSRJ9OHfeUtFUc52IJR9hEIhv9+f7TdpyCKRSEdHB/UXp7iHwiOe53t6emgvD01XYYxRQkQXP2jxwBzphj2onuO49957DwEHwOhBwAGQfdR+Ii8vzzCMgwcPVlZWer3eRCJhd6LqXw1BnJEHVXDYP3fexr4lXVWgr1OpFLXwjMVidMtwOByJROiTvL3IGMbhnK2mlIIACgjS6XRnZ6eu67ToSSQSjLGCgoJhPN1QnbMYJCMBWbRo0U9+8pN7773XNE2v17t48WKab08bfQVB8Pv99K2dCtl7VZLJZFtbG/0VeL3e7u5uev8FQejt7W1qaiosLPR6vTU1NT09PaWlpaN42AAAAH3+9Kc/FRUV5eXltbW10YYIahvhcrk0TXPuKqXb2wPs6Zw1d+7csrIyv99fUFAgSRKNm+3t7S0oKFAUJd0nHo/HYjHalHG2V2JZFiUC9Iy6rrvd7v4LnrOh7GOAxx9jkiRRyQatuHiep54mNPDe6/UKgiDLsmVZHR0dzvau9jtAawlKN+gvory8fPv27Zdddtl4HxzA+QkBB0D2vfnmm/a5fNKkSS0tLYZhUOsHe5dp/9oN5wZOO7+g6x72md7qa01q35j2ntBw+O7ubrpZJBJJpVKRSIQuvDDGhp1uMMYEQbD6GoNbfcNoub5pI4wxmt/W1tZmX5OhDSkTRP8EZMOGDX/961+//e1vHzlyxO12z58/3y7T6OnpEQQhHA4zx2gY+6+Aern39vY++OCDn/3sZwVBmDVrFvUWqa2tDYfDtKxsbGxUFOXo0aMzZ84c++MFAIALTWtrayQSOXbsGFUK5Ofn8zx/4sSJRCLh3OWRETTQGoNqMFVVNU2zq6tLFEUqQvR4PLFYzL4wQzd2uVx2ywx7cWJHJ7qut7a2vv/++3QXOnsOPt2wBQKBYb8V2eXz+TRNi8ViVMRBl4uo9QbNvFdVlZpxxGIxWZa5vlbltECyv9V1nd4KyjsmT5483kcGcN7CmFiA7KutrXV+SxNhaaKYnXE444azFXRkjGhlfWWl9o3pesKpU6fq6+sp3VBVNRgMRiIRVVWPHTtGW0OZY578MBw/fpyuWoh9ZFlWFEWWZco+kslkY2NjRqnqREaRx4MPPlhWVrZv377q6mpafxQVFTHGurq6Ojs7ac+wEy0Bq6urX3nlFa/Xm5eXN2PGDJfLJQjCnj17YrEY9WDbunVrOBw+fvz40aNHP/zww/E+VgAAOM/V1NSEw2EazR6JRKiWs6urS1EUj8fjLPzMWFHYf1K5B+2Qtes1nJtk7QIEekbn9Rj7QXRd7+joiMfjLS0ttEJgjsEouSs/Pz+ZTNoz7Gg5l06nNU2LRqPxeJzGz9PxUgMySZJor6vQR5IkURTp5zzPHz9+HCsEgFGCCg6ALPv2t79Nn5OdaE+pvf0yI60gGU22MoIM+qFzmcIY6+rqamlp6ezsZIzR+LG8vLzu7u7q6mrLskpKSqLRqN0pg4oLhnFEtHGjuLjY6/Xa1yJY34CVWCzW0NBgmmYuNtd88MEHN2/e/PzzzweDwcmTJ3McV1JSUl9f39nZKQhCJBKx+4xSjhONRt9///2pU6cuWbJElmXGmCzLqqpec801v/zlLzs6OpYsWbJixYoTJ060tLTMmDHjvffe0zRt9uzZXq93vI8VAADOT9u3b3cuJwzDOHDgQGlpqR1SWH2zS52LCnvHBOUXzmsqzhWIs89XxpUY52JG1/Xe3t54PG5PH+N5nhqQDfVwksnkMN+IPtnqTW574oknnnvuObuVBqUboihSEQdN1VUUxb4iYncop3eSQg37vaUf0vUnAMi6nE9VASaO9evXr1+//mzn8jOGC/ZaIaOIg86CzhLQjP2oXV1dR44cOXLkiJ1uULPx5ubmZDJJRZKqqhqGQYWUdEoe3nF1d3f39PRUVVW1tbXRJQg6xlQq1dXVRcUjwxhAO46cS5+bb775mmuueeWVV2hZxvN8RUUFY6y1tbW1tZUWaqZp9vb2dnd3/+53v6uoqHC73V6vV1EUWsMxxgKBwD333EOJRjwef/zxx91u96lTpwzD+OMf//jCCy+0tbWN18ECAMD5rbGxMeMnwWAwHo9TOQaNQmOOgOOMOYXz6ov9c/uOzr20zkbpJB6Pt7e30wwXXddbWlroloZhDGN8WyQSGfp7cJohTWobjFtuuWXNmjWGA02rSSaT3d3dFHYIDna3cvqTsh67bTm9OSdOnDh8+HB2XycAMFRwAGSLfTY9Y/sJ+zpJ/18543z7xqxvIdJ/cVBXV9fW1kaT7RljqqpOnz6dMdbc3NzZ2RkKhXRdTyQSuq5LkiTL8qxZs5qbm6ncgDbZOitU2Zm2xmSIRqNer3fSpEmiKMbjcZ/PR5Nou7q6WltbdV33+XyDe5OGo/91mDP21Djjzwf5gF/5ylcsy3rhhRf++Z//mdYfU6dOra6ubm5u5nm+uLi4rq5OFMXXXnutrKzM6/X6/X7apEMXZDRN8/v9kUjk8ssv37FjR1VV1Re/+EXLsvLz8xsaGnp6et5+++233nqruLj4O9/5Dko5AAAgK+isJ4piSUlJxq90Xbd7kNvJhXOx4bx8krEIYadXmDoXCc71CT1sIpHo6emh6Wl0As1oKzaM8W1ZsX79+uzWcfzzP//zli1bBEGgrmrUbVQQhFgsZncbsWs36AtnDzXa0ktdPGyqqmbxFQIAGU7jHwA4I1pq5OXl9c84KO+3h6rSD51fOHs92P07KfinHZscxzU2Nh44cMDuJBoIBKi+UZKk5ubmwsLCaDRqz5ZXVVUURa/X+/bbb7e1tdG4NWcxiN010941mvGaE4kENQ21LOvqq6+WJMntdicSCerHTtHGMAo3sl44mi3vvffe448//vnPf94eoXLo0CHLslwuVyqVamlp6erqKi8vp7ed3l7aVUvlM/n5+aqqRqPR22+/3ePxrFixYurUqa2trR0dHfv379d1vbu7e+rUqf/yL/+C1mIAADASzkDf7XYXFhZm3MBuCcFOzzXsIlO7FsOeF0bTQKjk03kXGshCTTqcHdMTiUQ0Gu3q6qLB8KS4uHjSpEkPPfSQ2+2mh6XrK0Pi9/srKyuHeq/+sr7e2Lx587PPPivLMq3NFEWhSbHl5eUzZsyg97OxsbG0tDRjUWfXs9CMOec7HIlEZs2ald3XCXCBwxYVgKzZsGHDhg0bzliN2f/ySP8b2IUVzlvaO2NbWlp27txJ6YbP56OP2VSpQRUEra2tdrrBGEsmkzS41H5Y5xrF7iJG+y+oaZbdN4sqWiVJsgPQqqoqnudPnTpVVVVVW1vb1NTEzpSJDEbWC0ezZfHixbfeeuuLL75oX3ihw4/H4++//35bW9vkyZODwaDH41EUxW62Sp1NaFwcTdSbO3duMpl87bXX9u7d6/F4wuHwvHnzeJ4PBoOlpaUtLS0tLS3jfawAAHCeOGMVgKIoGT28SP/rms6OGxlNQ9npXTbsu2ia1t7eXltbW1tbS+lGb2+vy+UKh8OTJk06cuSIveYZ35FqWV9v3HzzzWvXrrWXUvZ6qbm52b4uVVZW1tjY6OwtSpkRNemgdu/2+Hme53OxfxnABIctKgBZNryG4XYrUOZYT1BVp2magiA0NTUVFhbSNs50Ok2treiU2dXVdbaHpYsM9rbbQb4SSj2YY0duLBZrbGxMp9P2INjz0pIlSxhjL7zwwlVXXcUYq6ys/PDDDy3LmjNnTlNTU35+vsvlsi/d2Jtsub4WpIwxSZLC4XBlZWVVVRUNlmOM5eXlLVu2bPbs2TRdr6Ghoa2tbe7cueN7sAAAkKOcGzPPViJxtssq1unjXTnHbBQ747ALTu3rLrS3IpVK1dfX9/T02AuP4uLimTNn9vb2MsaampoOHjxYX19PDysIAm3lyOKBD1XWN6rMmTOHSl9p4kwqlaLdu6lUyu12U2bh8XicEQa9FYwxQRA8Hk9nZ6dzI099fX1XV9f8+fOz+CIBLnCo4ADIpv379w/ylv2bbjj7YlD/KvsSAW2RsOfJa5rW0NBAn64HSDdoPpzL5Rp8KnHGSzeMsVgslk6nB/kg5zRhizgYY0uWLLn22mubm5sZYxzHLV68mLYxFxYW9vb2njp1iq7G2BNz7YZhhmEkk8n29vYvf/nLoVBo+fLlM2fOpMd0uVxTpkyh2EjXdfqiurqaVoQAAADDMEDd6MCc1zzsbhp2sSfr14PDsqxoNFpdXb179+66ujpaeNglG6dOnWpoaNi3b19nZ+eCBQvsmfT2zLXxld0lx+LFi2+88UZ7pK5d/drY2EhrA0EQ2tra7FkqzjoOURRdLpfL5aL6WTtFCoVCWXyFADD+/90BOJ9UVlYOtZmWcw3R0NAQjUbr6+tpNge1C6Up69TjM5lMtra2dnd30wgPWoLQ/BTnekVRlEAgQGWrTU1NA++OgQxLliy5+uqrW1tbnfPtLMuqra19+umn6+vr7fn2zoswjDEaHXfq1KlgMEhNTxhj1AmloaHBLo2hhvaJRKK6upq24wIAAAzDoUOHzhginPO8b9du2H9mbJWlL2Kx2OHDh3fu3Llz586TJ08ahkG7UZYuXTp37tyCgoITJ07Q5/mKior8/Pze3l7TNOnj/bBLPu026hPTTTfdNGvWLMMwGGO0TTiVSkWjUbtkY/78+e3t7bIsU8mnPUuFko5QKKRpml3ZIYpic3Pzrl27xvuwAM4fCDgAsoyyiQzWWaa92pqamiiJkGWZenTTMoIu+KfT6UQi0dzc3Nzc7PP5ysrKKioqAoGA3+8vLS0tLS0tKiqaMmWKz+e7+OKLn3zyyU2bNjkffOSXUAoKCkb4CDnnM5/5TEtLix0bNTU1vf7668Fg8NVXX21ra6MrZnbnMKtvkF5HR8cHH3xgP8jWrVsDgYAoiu+++64zyaqrqztw4MChQ4eef/75hoaGMT84AAA4T5xxXTHwtRbngsQ5ZoW+pbpF0zQPHDjw0ksv7d+/v6mpSdM0SZKKi4vLysrmzp176tSpI0eONDY2Ujcu6jYaCoUaGxv9fj9tpx32HAO7BiRbsl43Onv27FQqRft/qcz2+PHjrK9oRRCEN954g6bDUoRBO1upiMPj8fh8vs7OTmcL0rKysuy+QoALGXpwAGRZLBbLaBll9Zsw7/ysG4vFKIBwu92qqqZSKUVRuru7VVW1+1xaluV2uwsKCkpLS+lUSh0fKAdJp9NUF6Bp2k033ZTxes7Z33TsTdhBKhk+9alPPfTQQ6lUqqSkhOoygsGg2+3+y1/+cvXVV0ciEWe6QRW8R44cYYy1tLREIhHG2E033eRyuY4ePXrFFVfwPF9VVZWfn9/c3Mxx3J///OeysrK6urpDhw5961vfysvLG+ejBQCA84iz0Ub/3zqbmtsZh2madF5LpVIdHR01NTXl5eWyLLe0tNA8eMMwZFnes2dPMBhUFKW9vd0eoeJyuerq6lRV9Xq9lmVJksRxnKZpqqrajcDGa3Rj1lcdX/3qVyVJeu655+jbdDqtaVp1dfWcOXOoLmPt2rUffPDB0qVL7cjDzjIURSkuLrZn2NFfQXNzs6ZpFRUV2X2dABcmVHAAZFlxcfEZf+48uzvP8bFYzDCMcDgsSVJPTw8NYOM4rri4WJIkXdeTySSdOzmOSyaTtPOTrrEYhqFpmt3K+7bbblu+fDk9rH06py6YIzyoVCo1wkew5Uq6QS699NJIJKIoyrRp09avX+92uyVJcrlcb7zxRkdHhzPdsCzrxz/+Md2L0g3GWEFBQW1tbSqVSiQSW7duffrpp1taWuiv4wtf+EJBQcE//MM/mKb5gx/8AKNVAABgqObMmdO/btReY2Sc/TOaf1GiQecv6vxFawzqK1FXV5dIJDweTzKZ9Pv9tEm2vr4+kUh4vd5oNJqxkSSRSHR0dDQ0NMTjcepubhgG7VKhYbG0aUVRFNq7QQ3UM0bS2mhmXFaM0qrjpptuisfjNDGX1mDRaJSKNSjR2Ldvn7NwQ1GU/Pz8SZMm+Xy+UChUWFgYj8ftXqQcx43vxBmA8wkCDoAsmzZt2tl+5bycEovFjh8/bppmIBDgOK6npyeVStklG4yx48ePt7W1xWKxeDze3t6eTCZpnisNorebj9KiRNO066677sorr3Q+HZ3Us7IDIltXXXIr3WB9/Ti8Xm9ZWVkoFLriiitcLhctWd555x1a3tEa8ciRIzfccIPzvpFIpLGxsaGhwe12a5q2bNky5w0KCgpmzZrFGLvssss8Hs+//du/UfUHAADA4PXv5eQcEHvGKxyUbtTX19fX10ej0aKiIuoowfN8IpGIx+M0hH7SpEm9vb2JRELTtPr6ep7nS0tLu7u74/H42V6Mqqq6rkejUVqx2MsVTdNouWIPpKcSD2pLwfO8qqqqqlL8oes6zSCb4NauXUsXpXRdp4ny1DqUzJw589VXX6XGoqFQqKCgQFEUykG6u7v/53/+J5lMHjt2rKuri94fXOcAyBYEHABZdu211548edL+tq2trf9QEk3Turu7S0tLqTrDMAyKNmghYl9ISSaT1GHU3pZCKwP6VSKRsBci1113Xcana0L91WmL7EiMV1npRPCf//mfTz75JBXCKIpCW4sVRaHrM7t27aLNKT09Pc57FRQUCILwl7/8RRRFunLl/G0kEnG5XPn5+XSp5/LLLz98+PCzzz77t7/9bWwPDgAAclsgEMj4iT2Urf+5m37C8zwVZhYVFUmSdPToUcaYYRiJRIIWG+l0OhAI9PT0tLS00FKkoqKC5/lYLEbT2fo/+PXXX79ly5bHHnuM4ziv1zvAvhh7XIsdf5imqWmapmnpdFrXdVVV7Z0vE9mtt9564403UhEHTYvfs2ePvSHl0ksvraqqKigoCIfDlPt0dnaeOHGipqbmiSee0HW9u7ub3ihd13mepwKZgwcP7tix469//ev27ds/+OCDzs7O8T5KgNzDXcifWwBGybZt21599dXi4uKmpqbCwkLW1yyDgobm5mae56mNNuvb+2rvg6WeGvY+FLuClJYC9iURWhaYpvmFL3xh7dq1A7yY8vLySCQywn/pK1euHMndSc6VbzDGNm3a9Pvf/54agN155500D+Xtt99WFIXqTjmOKy8vp7GyxO/3BwIBwzDee+89xhj9H8C2devWG264YeHChZZlVVdXFxUV9fT0UP+2F1988V//9V8DgcCiRYvG+DABACBHvfjii1VVVfa3zhDB3kdpV3OYpmmvTOx+orTwoOCe4njLslKpVHV1NQXxtOWEPorTBpNoNEoXY8Lh8Nq1a+fMmWO/gJ07d95yyy1er3fwh2BPcrEPwe/3V1ZWjvzNGYOFx5VXXun1enmeF0WxtLT0tttus/fd/PWvfw0EAp///OdPnDjR09Pz5ptvut3u3t7eiooKj8fj8XhoLUEXoqh8pqWlxeVyNTQ0TJ48+fjx4yUlJSUlJaFQyB7ERpdb6O/C3g8LAE4IOABGxe233x4MBmnjJeURpmn6/f6mpqa8vDxaTNAt7WiDtnHquk77aSnLsDfH0p/OdCOVSn3pS1/60pe+NPArmTx58qRJk0byL13TtMsvv3zYd8/FXMPW3Nx8xx138DyfTqcjkcidd94pCEJ+fv4TTzzh8/nsKff2sozSjX379lHl7RmH29O8G47jDh8+XFxcTBffVFWtrq5Op9Mcx02bNm3x4sVjepwAAJCbDhw48Nhjj5WWltK39nUR523olERbXGmxwfO8ffmE7jVz5szGxkaqp7DLK2g3ivOKC92dliKJRGLjxo0Zrcd++ctfbtq0SZblkRzUCAOOsVx4/Pa3v33uuedoBJ4sy2vXrp07d66dKG3cuLGpqekzn/nM66+/Ho/H16xZoyiKy+WiaIPCIwpH6Ive3t6GhoY//OEPU6ZMURSF1m/UaT4ejzc2NlLdbkNDQ0FBgd/v/8Y3vnHGlQbAhQxTVABGxbe+9a0///nPJ0+epMRd0zTaVOLxeBKJBE2Jp/Of3VmD0o2Mqg17PWFHG7TmuPHGGwcu3MiioYYjOZ1oZCgsLNy0adMPfvCDZDIZCAR27NixaNEijuOuvvrq//qv//L7/c50Q1VVuo0gCDNnzkwmk4ZhUMmG/YDhcNjlcpmmeeLECY/H4/f76eeJRGLKlCk9PT1tbW1HjhyxLGvJkiXjcMAAAJBDWvdV7X1Nbzt4sq89Oe14NQzDPj0JgpBMJkVRpMmmdokoc9SQWpZ14MABSZJSqZQoirFYzB5/bt/SuQihFcttt93Wv7H6W2+9NfLh9FTiOiTjtfb4yle+IknSH/7wB5o+U19fP2/ePDvgmDZtWnV19R/+8Ae68V/+8pfVq1dHIhFKN5xDZCkSUlWVMXbJJZc8++yzkUikubn5+PHjl19+eV5eniRJb731VnFxsSiKlZWVeXl5xcXF7733nmVZFRUVAzSAA7jQoIIDYBQdOnTo/vvvl2W5vb3d7XZTMaFzQ4rdfNuONqjRV0a6YdeA6LoeCARCodAgT+Rvv/32mjVrCgsLR/Iv3e/3z5s375w3O59yjQzd3d33338/td5QFGXx4sWapiUSiWPHjoVCoXA4/Pzzz19++eV+v5/juM7OTlVVaYGY8ThVVVWrV6+mpUxdXZ0kSV6v1+Px7N27d/ny5dRVvqurKx6Px+Px2bNnI+MAAICzat3H3rzr1oerGGPyzOtDoRBVAdgTTBRFodH1dntyKgh1PgYtPOhX9gqEnT5HlpYo9hZaGku/du3aG2+8sf+LWrNmzZEjR0aYcRQWFg7yE/sEWXt86lOfcrvd1KXrRz/6kdvttgs877vvvhMnTjhv/OlPf/of/uEf7FyD53lZlulbxlgikaipqXnkkUfq6upEUVRVdfbs2QsWLKDlIo2rF0XxscceW7NmjSAItbW15eXlqqpOnTqVOea4AVywEHAAjJb169czxjiOKyoqampqsiyLWlSyvnUDtQ51Vm2wvqsltDrJ2JZC0cbZnu6M5/gdO3bcdNNN4XB4JP/SVVUd0o6JCbLayK7e3t6NGzfSxDtJkubNm1dVVVVUVESbYKuqqjRNo79HnueDwWBGg7Suri7GWGdn56JFi0KhUE1NzZQpU2RZpkJfxhjNkFMUhSbmaJqWSqWQcQAAwFkdfJwdepwxRhmHVbhC9hdzHEeBhc/nc7lcbreblhBUmkGtNOjetLqg0xBdTbF/bl9xsb+mug8KONasWTPA9tjS0tL8/PwRBhyRSGT69OlDusv4rj2eeOKJZ599ltKKz3zmM1dddZXdiWPLli0nTpyg9vOJREJVVY7jrrnmmuuuu86Za9gsy+rs7Kypqfnxj388f/5851adUCgUDAb//Oc/u1yuiooKGt1SUVFh19EYhvGxj32srKxsDA8dYMJBwAGQfRRtZOju7o5EIvbKg5J463QZ/UTtWtBgMBgOhwf/AuzT/I4dO26++eZwOGwvXIZhqAEHG+91xiiJxWKPPvoo9RZljM2YMeP48eMFBQWiKFZVVVEHWQo4TNOkKlPWF210dXWdOnWqvr4+Eolce+21tPQUBKGpqam4uJgGy1GFCCUj0WiUIrDZs2cvXbp03I4ZAAAmqv/a8sA/uf6TvqaMgzGWFvyMMb5kSTg4WVVVardBv6KtKLTMsGs6nCsQ5uj/ZTrQjTVNy8vL678ayTjjl5WVjby1+bx58/pPhxnYuC88tmzZsnXrVhp8+9BDD7nd7j/96U/UR6Opqammpmbx4sU+n+8Xv/iFZVmapn3xi1/sXwJDp/4DBw7E4/FTp07ZP6do45VXXunt7Z09e7bducN5X0mSYrFYXl5eWVlZQUHB8Eo5fv3rX9uFxrT8wCIEcg4CDoAsO2O6QSjdoGiDfuJcVWTUa1DJhmmaQ4o2MqxZs2bkAUdBQcFQL6SwCbDUGA319fUvv/wy6xuLM3PmzBMnTgiCUF9f73a7ZVnmOI4KShljXV1dlG5QtEGPcMMNN0Sj0aKiIpfLJYqic78Sx3GSJLlcro6OjlQqRf9xTqVSc+bMwfICAAAyvPL7n3Xu+f8uneufHP6oo6cdczDGfDM+JfmKmGNGibNkg9qZOy+uZFxrcS5I/H6/aZp5eXnnfEk33njjTTfdFAwGR/j5YsaMGQUFBcO44/iuPT796U/TMJprr7125syZ9913H2OsrKxs9erVM2bMSKVSVMn70EMPGYbR0tJyww03rFmzxr67ZVkffvjh4cOH6dtAIMBxnMvlcrlcL7/8cjQajcfjl156qSAIGc/r8XhM06S9sY2NjSUlJe3t7V/72tcG/8ofeeSRffv2vfvuu3wfe3FCTcFM07z99tuxGoGcgIADIPvOlnFEo1FBEPpXbTgXE3SdJBgMyrLs8XhG+EpaWlr27t2bl5c3koBj3rx5di/MoTr/Yo6GhoYXXnjBMAw690+dOvXgwYNHjx71eDzBYFBV1WAw2NPTQ5fFqqqqamtr7fvecMMNVKyhKIrX67VOn4rHGKMLMrIst7a22tfcaK/KRRddNObHCgAAE9dLTz2w/5UNAbcwc5JLErh5Ze48n2hnHK7iha7ihaxvy4ndPsNutGH1tRFlju2xducvWpCEQqEhDelobW19//336QQ3kkNbtWrVSO7Oxmn5sXnz5q1bt1Kl55VXXvnKK69Qt1RFUT796U9fc801qVSKtrHcd9990Wi0ra3t+eefp/um0+kPPvigurqaMSbLst/v93q9hw4dEgTBNM29e/euXLkyI9ro6emxLKu2tvYTn/gE/RUnk8l4PO5yudra2iorK1esWHHO1/yrX/3qF7/4hdvt7unpCYfDlG7Qr5LJpMvlsvo60WqaxnHckiVLbrvtNiQdMJEh4AAYFf0zjlgsZncj718Cmq2SjQwtLS27d+8uKCgYScAxffr04V1IcTqfko5Tp07t3r3brh0tKSnZtm1bZ2dnQUFBMBikso7S0tLGxsYdO3bY97rhhhvob9/tdns8nox0w15rUmd1WZbff/992kZrWVYymbzyyisnTZo01ocKAAAT1Z9/98C+l34Z9ooeRfAovCLxqsSJApfnk441JjqV2R/0Vuh97FrR/pyhBv0ZDAYVRXG73UN9Sa2tre++++6wL4oQTdM+8YlPjOQRbGO/9tiyZcszzzwjimJhYeHixYtLS0t/9rOfSZLkdrvvvffeJUuWJJNJ+vZHP/pRd3f38uXLv/jFL6ZSqWeffVZRlNbWVuquas9hicfj3d3dLpeLHp9CjVQqlUwm6TY0ha24uLiqqornebfbHYvFqOeoIAjLli0b4NX+6le/+vWvfy0IQkdHR2Fhod03hPV1xOc4Ttd1SZKosyzVIPM8v2zZsjvvvPPiiy8e9TcUYOgQcACMFmfGoes6zdRw1mtIkmSapizLtLwYpUnmzz33XElJybD/padSqcsuuywrr4TWGQNs4RneA46X559/3s44RFH83//93/b29hkzZpSVle3Zs8fn8yWTSSpApdtQSbDX600kEgUFBfYCwpluvPrqq1dccYUgCLTb5eDBg6WlpXSbRCLxla98ZbwOFgAAJpoXn3zgwCsbgh4h4BIUiXcpvCxwksgLPBN57r3ukj1txRn1GpZjQkpGL3Nd1/O4JtFX4i0oH/ZLOnjwYFNTk92Fanj8fr+zs+YIOZcKw1iBDGOlceWVV7pcLkEQysrKLr300uLi4mQyed9997lcrueff76pqamoqIgxtnXr1qeffnry5Mlr166dO3fu1q1beZ6nqyOTJ09mfRHDkSNHAoFANBqlGoqM59q/fz9jLBwOL1myhMblJJPJcDi8b9++j3/844ZhxGKxFStW5Ofn93+dN9988759+0RR5B3oV/TUdt7R29sbj8f7P8KTTz6JjAMmIAQcAKMri5/nh+eFF14oKioa9r/0Qc6InYDGIP5wZhzNzc3V1dUulysajfb29uq6bkcb8Xicuq74/X6fz2dvbWV9l2icV9Lo55IktbW1lZSUtLW1UTmraZpz585duHDhaB8UAADkiqd+/MWeur0+VXDLvCrzisiJAicJnMBzPM9xjDUkvJbF6mKe2h6XZVoWY5Zl1UbVIlevaVq6YeYrMS1l+Pge0ehtl2bqwTkjeT3V1dU1NTUjDDhUVZ2wE8QGs7TYvHnzCy+8YH979913T5kyJRKJ3H333VdcccWaNWuohPOqq66y56dcdNFFq1evPnr0qMvloh0uFDdQq1FJko4cOVJaWko3plCjtbW1paXlnnvuUVWVYizDMGRZDoVCGduO0ul0WVlZxlru+uuv37VrV15eHs2ypafr7OzMy8ujbxljtKu6p6enf7DC+nqHHTp0aFhvJMAoQsABMOrGN+N47rnnioqK+rekGqRhjFCZyLKeejgzDsbYBx980NnZWVJSQiuJ1tbWnp4eRVESicTMmTNFURQEgdYN9gLCeT2NPP3002vXrqWhKg0NDfv37y8rK+N5XtO0ysrKa665JruHAAAAuevdbb84+N8b3QqvSrwi/r2Cg+MYZRyMMVrrm6ZlmMywLMOw0oaV1i1NtzTdPJ6emjasNnHmyF/MoUOH2tvbRzgjtrCwkLZpTHADrCiuu+46++s5c+b88Ic/FEXx3//939vb2y+55JJLLrmktrb25ZdfPnjwoH2zgoICWZbLy8tDoRA1FrUsiwaraZrW0dFx8ODBaDRKoQZjzLIsCiCozNPlcgUCgf6bj+yvg8FgIBDIz8/Pz8+/8cYb9+7dKwgClW/Q41DaQkkHZSWMsZ6enlQqdbbDtCxr3bp1434lDyADAg6AMTJeJ4Dt27dblqUoyvDuPpIOoxNfVvIOyjji8XhNTU1+fn5vb299fX13d7fX6w2Hwy6XK5VKzZgxQ5ZlSZLoT7uIo38bDsLz/I4dO15//XW3223XiHIcl06nRVG0LGvx4sXoZw4AAKS1enfVaxslke+p3SMLnEABx0ftFJjFGLOYaf094GjSgs2poGlax/VsRglvvvmmc6fD8AxjRuz46r+WcAYcjDF7WspPfvKT3bt3P/LIIzU1NR9++OFLL71kLwMYY4qicByXn59fXl4eCARkWdZ1fdOmTUVFRZ/97Ge9Xi9jjPY767pO41p8Pp+qqoqiWJZVV1dXWlpqV4PSnmjG2FtvvbVq1SrLssSSEiMabTp27Ic//CHd3cZxXDKZpKeg3dO0M8We+ndGlmXdddddd911V1beRoBsQcABMHbGJePYv3//qVOnhh1STJs2bXij1HPRsPOO3/3ud2+//TZ9XVxc3NHRcfLkyZ6eHkmSAoHAzJkzadWiqqrL5XJmHGcMODiO27Jly6lTpwzDoIAjlUq53W66SmPfnjFmGMbXvva1JUuWYMYKAADY/v07X6YvitQuZrGmVJAxxixmMdZCX4+OHTt22JUFw36QYc+IHXf2KuKHP/whbSSx3XDDDddcc82mTZtOnDhRWVm5evXqF1544Y033qDfOjeuTpkypbu7u7KyUpbl7u5uatnmcrkSiQRFD7Is19XVLV++PBwO26EGcxSEMsaefvppam1uN5f9r9dfv+kHP5geDD7/4ov/z9e+xvO8x+MRBIFamzNHV1GaYa/r+hn7bmS46KKLnnrqqSy9fwDZgYADYKyNccxx4MCB+vp6v99vOcZ2DFLuNuDIiiHlHY8++ujf/va3QCBQUVGh6/rBgwdramp0XWeM+Xw+r9cbCoU4jqPa3VWrVr3zzjs0143n+YweHE899VRDQ4OzdtTZ1dy5cKQxfqZpUkEHYg4AALCN/WWVXbt20ZSNYT9CKpW6/PLLs/eKxsGGDRueeeaZrVu3Zvz8N7/5DWPsqaeeev311++77z7TNO+9917nwoy+5nl++vTpoijm5+erqvrSSy+VlpZSmYbP5yspKSkuLrYveNhrA0o6amtrS0pK6urq7O7y9l6VU6K4dPXqSln+2X/8x8O/+AXlGlRuY7f8oCUH65veMpgBfJZlHT58OGvvHUA2IOAAGB9juex4/vnnCwsLh5pusPN9f8qQDCbseOONN44cOVJYWHjttde+9tprv/rVr+LxuKqq9uUsSZIKCwsjkUggEFAUxW4k1tzcXFBQQKuQ7du30xUw6jTGGKPVht25g77VNC2VSqVSKXuJI4rinXfe+fWvf3103wgAAMgdY5xxvPnmm/Z5aniyO0JlvESjUWqf4bRixYoVK1a88sorDQ0Ny5cvX7169Z/+9KcdO3ZkZBzUoqu0tHTGjBmGYbhcrpdffjkvL09RlFAoVFlZ2dnZefTo0UsvvdQ5+qShoaGuro6WBCtXrmSM7dixY9WqVdSGI5pKpadMWbBoUbkg/OinP/3Dz37G87yiKDTcjR6BCjeovNQ0zQFabzgh4IAJCAEHwHgam5XH9u3bTdOkT9qDjzmyOCD2PDNA2HHq1Cma7kZ+85vfbNmyxe120zKCaj4NwxBF8ZOf/KTH45FlmUpD6QLLyZMnt2zZIkkSlW9QR1K7apRKOUzTTCQSmqb1/683z/Pr1q274447RunAAQAgF41ZzPHGG2/wPE/nteGZyCNUhqS+vj7jJ6FQqLy8/P3336dvf/jDH77++uvbt293FrzYAQdjTJbl/Pz8srIyGpgSCoVoOUGLgZMnT9IeE8uypk2b5vF4VFWVZdmZLtnlG7WmWbpkSUlFRYTjfnbffc/cfz9dX6EbK4pCQYm90kin04P5hEi3eeKJJ1asWDHS9wsge4b/HyAAGDn6qDzaK4+CgoITJ04MdWybPZAMMth/X/2TDme6wRi79dZbLct66qmn7JZdgiCYpplMJnfu3Llw4cKCggLTNGmBcvLkyaeeesqZd6TTaZfLRQ9FZSDpdDoWi9EFmf4vzDTNDRs2mKa5bt267B82AADkprFZbJARXjrNifkpg+H3+zOKODo7O53Zzfbt2y+77LI33nij/8Un+omu662trdFolIopEomEoihdXV2JRIIxxvN8LBajbarNzc3UUtTn8ymKMmnSpIqKClmWm5ubJ02aVBuNWoWFgiQxxtKM/eOqVVs5jrafUJ5iX3pxu92madLO2XMeoH2bEfaUBcg6VHAATBSjtPKgZc3nPve5Q4cOud3uQd7L5XItWrQo6y/jfJ0lNvAGlscff3zz5s1ut5syDsuydF3XNM00zZUrV5aUlNDPn3zyybq6umQyGQwG+dPZyUgsFhvMf7TXr1+POg4AAOhvVE/EO3bsoI/Kw36E0egwOi4rkDPuUlm6dGlnZ+fx48fp269//ev/8z//c+TIEWeTUbutBlVYEFEUPR5PXl5ec3Ozrut0XYSuhVA8QRdFDMOwh8JyHLdw4cLm5mZh5sxp8+cXVVSEw+EAx4UZmxeJ0NIiY6VBpaPOjuZn47wBBqnARIMKDoCJIrsn4IyP3N/5znfWrFljb4gYmKZpv/jFLz72sY9l5ZVcCAao6WCMffWrX7Usa/PmzTSvl9YQjLF4PL5jx4758+dXVFT4fL4jR464XC6Px0MXTzo6OsLhsL3oMU0zHo8PMpLeuHEjYwwZBwAAZBjVT/vBYLCpqUmSJNM0h9H5S9O0oaYbg28HvmHDhrHMOPpXcDDGOjs7nd/u3bu3vLz88OHDzpFq7PQR8vROGoYRi8U0TaPuXfRbwzBoQxDHcalUirIJyjjoqbdv3160cOHU/HxJUbi+Oov+c1/tag4q3zjnXxyujsMEhwoOgIloNGKOt99++8Ybb/T7/YqiDHCXWCz2+OOPr1q1KisvYGADHOYglywTtiSk/+t/7LHHnnzySWqEThGGYRg0g23mzJkej2fz5s0ej0cURfoLoksrtHARBCGVStFMlkHiOG7z5s2YqwIAAGeTxXMonfV+/vOfP/LII4FAwJ56PqQHmTVr1u9///tsvaSBjcH6oX8RRygUmjp16rvvvkvfTp06derUqVVVVcePH3cWcbC+NYATzT2hVQHdkj7EmaapaZphGFTHQX/SDWS/f+rHPz5p6tS84uJwJBIMhXyMKYx997bb3t62zW4pavf5sixLFEU7QDmj/p8cUcEBEw0CDoAJbeQn4IxP2tdff/3+/fvdbnf/Ug5d1++8887bb799hM84QUyQ7MP5/u/bt++b3/ymvVeFMUYZh6ZpJSUlr732miiKLpdLFMVkMunz+TiOU1WVViqD7GfuZJomepsDAMDAsni6LCsre/TRR4c3mZ4x9uijjy5dujRbL2YksvWe9G81esUVV/z1r3+lr6dOnTplypTq6uozBhzOjINqPyl9yCiyoIkn6XSa2nBQ0kG/yp83r3zBgkhpaX5RUTAScblcHsZcjP3ntm07t23b2ZdxsL5ZbKZpUhPTsx1O/4+NhmGsX7/+7rvvHtHbBJBVCDgAcsMIz7UZMceuXbs4jtu7d+8777wjCMLFF1+s6/oFe34agyjEfv/37du3efPmgwcPUh0HY4w6a2iadvjwYVmW7dH0NEKFljLOCzKDRLdfuXLlb3/726wfDgAAnGeydSqkyfTDuOPSpUsfffTRrLyG7BrJO9O/iGPp0qXHjx+nvSqhUGjp0qWWZf33f/93xiwV1jcY3hlz2EPWnDemUCOVStkVHPSF4vdPvfTSwrKyUEFBuLDQGwy6VVVlTGHMx9jvtm372e232+UbjDGq4FAU5Wx7mft/ZqSfrF+/HhUcMKEg4ADIPcM+1w5+qyqMRuphv/933303xRm0RqE6jsbGxvb2dmonRr+idYwoikPanML6ljtUZbp8+XJkHAAAMHgjOQNu376dMTbwNoczmjjlGwMYxjuTUcQxdepUxpjdZ/SKK66wLGvPnj1dXV1n3KXiDDhoSUDrhIw+HbSP1blLpXDhwsmzZ4cKC8OFhf5w2O3xuDweF2MKY17GnqYijpdekiSJxtgTVVXPWMGR8YGRliW0X2bp0qVbtmwZ6tsCMHoQcADksOEtQRBzDN7ojbb57W9/+/vf/55qQS3LSqfTNTU1zc3NzupTn8+naZrb7R7qf6gNw3AuUJBxAADA8Az1PHjgwIHa2tpAIDCke03Y8o0BDPKdySjiyAg4li5dGgqF9u/f39DQcLZdKnYphyAIVMRBNZ6sL3egVQTtUqEKDs+kSYXz5hWWlPjz8kKRiMfnU9xut8ulMqYyJjP27LZtHGM7X3ppz5//bBgGPaMsy5ZlqaqacQgZixD61q4iWbZs2ebNm4f67gGMHgQcADlvGB/CkXEM0qjuXunt7e3o6KB5b4WFhe3t7W+88YYdcNCG2AGKRc+G2qpnbH6++OKL77777ol/cQwAACamwZ8Qn3vuuUgkMqSTV06Ubwxg4DfHmXGEQqHi4uKjR49SEQT1GW1paXn//feZI9qgG/cf5mq34XDuUmGMGYaRTqepiEPwePLmzcufNCmYnx+KRFS32xsMqh6PW1FUxiTGZMbcjG3Zto1x3M5t23a9/LLzoaiFiv2t8+t0Os0YkyQpY41x6NChob5jAKOHP/dNAGBi27Bhw1ADi/Xr10+QHpwT2Wi/RV6vt6ysjMo0DMO45JJL5s2bZw+xZ4zxPD/UzSlnTDcYY3v27Ln55psfeeSRvXv3Zu0AAADggjH4xcacOXP6T0gdwO23357T6Qbre3PO9v74/X77a+q+4fP5KACib10u19kyBfqW2NtPMqbJsr5yD+KdNMkfCsmqqqgqx3FiXyBiMUbdR+0vmGWtvPrqkpkz6bv+mZT9SugFULzSf42xe/fuQbxJAGMEFRwA55WRfCZHWUd/YxYD3XbbbZIknTx58ktf+hKtHjiOo/INWZYH+SDUOH2A/ueMMdM0P/axj91xxx2YIAsAAMNzzpPjkSNHjh8/PpiNKrfffvvXv/71LL2uiaL/++Ms4iguLuY4rrS0dNeuXYyxK664oqWl5fDhw8lkMiOzsCs67VkqtEvFHiFv39gwDF3XTdO0FCU4e3bBpEneYNCfl+dyu73BoOJyub1eURRdjMmMiYzJjMl9RRyWZf3x5z+vP3ZMEATDMDwej10eQp8Tz1a4YVu3bh36jMLEMbTKZwCY4CikGN7HcvteSDrG3qZNmxhjGzZsuPfeex944AFatdilHIM3cLrBGON5fufOnbt27VqxYsUdd9yR6xfNAABg7J1zsTFr1qxQKHT8+PFUKnW2vSo0nP78SzfOiIo4KOPweDwzZswwDCMUCnV2djY0NDQ2NiaTScZYxnhd+tau4GCM2bNgRVF03tj+wl1c7AuFeEGQVVUURVFReJ7nBcE0TYExkzGLsdOmslkWx3Gfv+eeZ3/+81PHjjHGdF23r6zYhRsFpaXhSZNM0wwWFuq6bup6zQcfRNvaRvt9AxgGVHAAnLdGXn2ApIOM5XaeDRs2/PSnP33ggQd4nlcURZIkRVEGc8eMxqKD4fF4Fi9enHN93QAAYOIY+BTZ0tKiKEp1dXVvby/9xLKsYDAYDodLS0vZ+bjSGOAN0TQtGo263W5Kf+iHRUVFlmV1dXXF43F7aCtz7DphjNldRe02HBmzVEzT1HU9ZhhFixYFCwoC4bA/P19RFLff7/J6JVlWPR6Z5+3aDanviye2bWMcR0nGcw8+2HT8OJWOWpal67plWQs/8Yk5q1aZpmnouqHrJtWKpNOvn95YFG04YOJAwAFwnkPMkS1jFnNs2LDhvvvuu//++ynj8Hq957wLdSo9W+3oGUmSJMtyLBbDjBUAABihrJwiz5v1xjnfDUo6NE2jjp60l6e7u7u7u/uMAQfryzgI7VKx963QIDZd18uXLSueMcMfDnv9ftXr9fj9qtvt8nhUt1tUFBoAS1tUFMZ4xhTGntq2jZ6MMo4/Pvhg04kTLpdL1/WFn/zkwssv/6jxh2EYhmHquqHrd9x117/cfPP+0/tubN68edmyZVl/JwGGAQEHwHkOa47sGpuYY8OGDVdfffXOnTtFUQyHwwPfmAa8ZTRUHxjHcV6vt6enh75FxgEAACOHJYdtGG9Fd3d3R0cH9RqnAg3WF3PQF1S4QV/QLBX61uPxNDY2CuFwZPZsTyDgCwa9gYDq8bg8Ho/fL8qy6nbLiiJynNBXuCEyJvXVcfzGLuJgzDLNFzZsEEWxeOrUhZ/8pGmalmEYpmmZpmEYd9xyi8nYd2+++YN+XUXRhgMmDgQcAOc5VHCMjewGH/SeU8bh9XrdbvfZbknbcYc0jY8WQ/F43DT/vg8XGQcAAGQFFh5kGO9DTU2NM9Fgp49HoZ+EQqF4PE5hh13TUd/aWr58ucfvDxUWqqqqeDy+UEiSZdXlUjwe+kLqCziE0wOOj3apMMe8FstilkULDMs0v3HDDSZjJmPv7d69+eGH/3ammSmWZR0+fHiE7xhAViDgADj/YamRdWNQx2FnHG+//XY4HJYkqf9taIvsGX81AFoM9R9Ai4wDAABGLlunyPNj7TGkd6Orq4t2qThjjozIIxgMiqKYSCREUaQqj9LS0mPRaNHUqarX6/b5fIGAy+tV3G5ZUVwej6yqkizLiiIKgsSY2Pc/quMQ+hVxOGMOyzTXfe5zOmMWY49t3PjEww+f7ZVblnXXXXehiAMmgiGUNAMAwJihJdG2bdtWrVrV2dmZSqX632aotRuMMdq72z/dYIzt2rXrlltuGdaLBQAAyKbzI91gQzwQCi9kWabqCdaXNpimaWcOXV1duq57PB6rr8iiMx4PFhVJiqKoqqwoHM+LoiiKIi8IvCBwPM9xHOvbx0otPWiWisEYY8xk7Parr2bMMYuFMY7j7rnuum997nMiY7/duPGSOXMGTjcYYw+f/QYAYwljYgHgHM6bRUaO2rZt29VXX717926v1+ucqEKtN4bUWJRurGna2W6we/fuW2655YknnhjB6wUAABiR82zh4TyccxZ0TJ48mb5IJBIcxyWTSU3T6HRPp2+O4zo6OjiOKy8vb2pqUlU1LstBr1eUJFGWRUkSRZETBI7jROo+blkcz3N9l7VNx8c/jjGz73/Msj7aqMJxHGPf+uxnLcYe3bjx14OLLWiBcdddd23cuHEIbw3AKMAWFYDz3EgqRc+zFUZ2jVm3UfoiHA5zHBcIBFRVZYxRCcZQW2/wPG8YxjlvuW7dunXr1g3r9QIAwIUOG2MHKTsLCUXhiov94bDq8bh9PrfXq6iq7HbLiqK63ZIsi7Isq6okSQLHyYzxjAmMSX37U8S+fhwCY5teeokx9u2rrrIY+9XGjY8MLtqwLIvyF7/fn0qlHnnkkeXLl2fhuACGC1tUAOAMNmzYcIEsL4ZtbN4fe/Xz4osvWpbV3d2dSCQomB5GuuHsKjqAhx9+GIWmAAAwLi6E5cf69euzdpmE40RJEkRRdbs/GrzC8wLP20NYeI6zLItxHM+Y6diiYvVtVLG/vuOqq8plecMvfzl7+vRBphv0FJZl5efnx2KxRCKxZ8+e7BwXwHBhiwoAMHZhrCeybsOGDWNTx8EYu+SSS1588cVrrrkmkUgwxqiOY/Bo/TH4kr2HH36Y47g777xzyC8UAAAuYKgbHYxsrh+SSaG3VygosExTlGXZ5eJF8aPLGoLAOI7RIHnLsjiOMWY6rm9bjHGMWYwdbmjgOe5IQ8Prr776+tatg7+CQrUblmW1trZm53AARgxbVADOf/1PohfOGmK0jfFGlbfeeuvaa69ljLndbq/XO8i78zw/pHSDMWZZFs/zBw4cGOIrBQCAC9cwzokX8oIki0uIwLRpkXnzRFl2ud2SqiqqKsqy6nIJsizJsiCKsiyLjPF9O1N4xmpragSeP3nqlCCKHMdRAw7LNP/1mmsURXH2/BoAtd5wLjCWLl26ZcuWbB0XwDAg4AAAGKkxmxrLGPvpT3/6wAMPWJYVCAQGs/7geZ7jOGrAPtQnRTMOAAAYknOeEC/kRKO/7K4fPJGIr7g4r6JCVpTZc+cKgiCI4sFjx1Svt7OlRVEUWZZ7Ojt7enpkRRFEUZJlThAEQeBpxgrHMcva/H/+z8kDBwYuFLULN/ovLQzDOHr0aBYPCmCosEUFAGCkxnKvyve//33G2AMPPBCPx9Pp9MB1HLQEGV66YVnWww8/TJPth/9yAQDgAoY4Y2D0/mRrCRFraYm1tDT97W+Msff6HvzpF1881dXlD4c9fr83GKTmo6ZpcqZpmqbQV+NpD2WrqKysPXRogGehW56tqxf1/gAYR2gyCgCQBaO9hnOufr7//e9/73vf03Vd1/V4PD7AvYaxOcXJueIBAAA4pw2nG++XkxtG6Y2ilcP82bNTmqan05Zl0Z+GYdDCgEKK0xYJHFc2Z87Zlg32cPqB1xXvvPNO9g4CYMgQcAAAZMdYruTuvffee++9lwKOdDp9xtuMMN2gRQzGqQAAAIy20cs4FsyZY+q6Fo8buq6nUqZpGrpuGoZpGIyuZDBmOcoxplRWnvHaxgDbUjJ8tOEFYJzg/38AAFkzlhnH9773vZUrVzLGenp6+v+WWm+MJOAglmVt3LhxJI8AAAAA5zRKS4jfbtoU7ey0GDPSadMwKN2gIg7LNC3TtPqwfguGZVdd9fWHHvrKf/zHgk98gp19W0qG3bt3Z/8wAAYNAQcAQDaNXsbRf4/un/70J8aYZVk0O9Y2ktYbGbBFBQAAYGyM0r6eAq83lUwmentN00xrGmPM1HV7r4ppmuz0c33FvHmMsZXXXLPiqqt4nrcvmWT9hQGMBgQcAABZNpZ1HN/97ncZYxlZBs/z2Uo3LMvatWvXCB8HAAAABinrqwiXIGiJBC8Iuq5zPG8ahsWYZZocxxm6zhiz7DWDZVHYUTp79qprr+V4XhBFQRQXfvKT8z7+8UE+3c6dO7P7+gGGBFNUAACyL7t90Qdw7733chx3//338zzvcrnYiFtvZOA4DptpAQAAxlJ2VxE+l6u+paW3u1txu/VUypBl0zD0dFoQRZ7nLdO0qHUoY1TIMWX+/NJZsziO43ieMcYLgiCK8y+/PJ1OHx1EA1EMUoHxhWUrAMBoGZse8t/73vfuvfdeGqdib04Z7ScFAACAUZXFJUS+x2MaRjqV0tNpQ9dNR+HG3yeq9F0aqT10qP7oUcZxPM/zgkCXOjiOm7tqVcXChed8LlRwwPhCwAEAMLrGIOP47ne/u2rVKk3TaHPKaD8dAAAAjIFsXSlJa1pK0/RUyjAMPZ02aJaKaZqGYZqmc4oKs6zyuXNZ35x4quMQJEmSZUEUpyxadM7nQuEnjC/8/w8AYNRlK+MYoFr1+eefX7RoUVZab2RYt25ddh8QAAAABm/kMcekcDgRi2nJpJFOG4ZhmR+xqI2Xsw0HY6WzZ3/s+usZY1TBIQgC7VLhBUFR1ZK5c7NwSACjBgEHAMBYGIM6jj/+8Y+VlZXocw4AAHD+GeFCIs/l0lMp0zQtw/j7gNi+bxlj9naVsrlzGY1R4zj6k1kWLwiiJImyHCgszMrhAIwSBBwAAGMkKxnHwC3Htm7dumDBgpE/i+3iiy9etmxZFh8QAAAAhmckpRx6Oh3v7U3EYqlkMqVpejptpNM0I9bsCzv+fmvan8IYY4ynCg5BEARBdbsLSkrO+VxowwHjCAEHAMDYGYM6jq1bt86fPz9bj4b9KQAAABPK8GKOokAg0dtr6LplWXoqZTFm6LppGIauM8ui+o2P2nhZFnNUcPA0ToXjaJeKpKqTZs8+27NY9n0BxgkCDgCAMTXyjOOcc+OyVceB8g0AAICJaRjLCbckUbdR0zRNXf9oiwpjpiPacG505fq2qAg8z/O8KEm8IKhud2Tq1CweCEB2IeAAABhrY1DH8cwzz9xxxx0j7MeB8g0AAIAJa6ilHC5B0BIJLR43TZNiDj2dZnbYkbFmsKeoMEYjYxnH0UYVXyBwtqegm69YsWJ4RwQwcgg4AADGwQgzjnMWcdBt7rzzzmFnHOvWrUP5BgAAwAQ3+BVFYSAQj0ZpUizHcaZhcDxvGAbNi/2oy2j/XSo8z3EcL4qCKAqiqLhcittdPHPm6B0RwEgg4AAAGB9jUMexfv36b3zjG6azbdjgXHzxxSjfAAAAyAmDX1EoPG8YRiqZ1FMpwzCMdNrQdY7jLMcUlYxLIxzP8zzPGOP62nDIqurNyzvj42OUG4w7BBwAALlkqLHIN7/5za997WvpdHrwd7n44os3b948xNcFAAAA42aQywNVEFKJBMeYlkwaum7oOmPMtKfGMmY6Ewqub4cKzwuCwPM8Lwgcz8uqGikrO+PjcxyH8k8YXwg4AADGzTCKOOzNKYPZpUK++93vPvnkk0uXLh3MjZFuAAAA5KLBLCqUVKeWSCQTCcZxeiplWpah6zQm1jRN5qzg6NulwvXFHLwgiKIoSpIoiqrbnV9RMaqHAzA8CDgAAMbTMDKOYdxl5cqVTz311B133DHwdpV169Yh3QAAAMhRA68QUi37peZ3ErGYnkoZ6XQ6lTINwzRNyzAs0zQNwzJN6sFx2iQVxhjH8YLAC0L57NnT58+fsWjRvBUrSqZPP+OzDP4CDMBoQMABADDOht2MY6hriPXr1z/xxBMLFy7sH3MkEokpU6YcPnx4fZ/hvSQAAAAYR2dbVPxjRUO69QBjLBA/qSUSWiJh6LrVtznF7MOogsPeqGJZH1Vx8PykKVMsxqjhqCiKSz71KfvB/XK6xBtfWdxe4o2P+hECDIhDJxgAgIlgjDOFtra2rq4u+trv90cikTPebAw6oQIAAEDWZawr7l509Ce/e48xFud97QXLiisqgvn5isvlDQRkVVVcLlGWRVEUZZnneUEUaYQKo+ajpmnoeqSkhOatpDVNSyR6Ojv/66H/m26qLvUl6Cl+s246Y4zN+Sqb+9WxPlqAPuJ4vwAAABgH+fn5+fn54/0qAAAAYFRs2LDBmXFQusEYc5s9baZp6LqeTisul2EY1IbDNAxLFPtmxZqCIHxUvsEY47hISQmjlhyMMZ4XBIEThLlzyzti+5kdbZBDj7O2fezSh8fwWAH+DhUcAAATxcTZGILCDQAAgPOAvbRYwf/ltQ+76OtuzxRhynJPIBAqKJBdLo/fLyuKrCiSogiiKErSRwNTqIjDsizLChUWchxHW1kMXdfi8WQ83lRb+6/CQ2d+YtRxwDhBwAEAMIGMb8aBXAMAAOA8Q0uLul2/D3kEjvvoh6lIJVd+cbiw0O3zKS6XrKqqxyOIoqwogigKgvD3gIMxyzTtgMOyLF3X08mklkh0trTck/j3sz7x594ei8MDOB22qAAATBTjlW4g1wAAADhf0V4VnmMcxwk8M0yLMSa37LcSbSnuMkGaKSuKaRiGrvM8bxoGLwgZu1QCBQX21FiLMarv4Hn+EoYIAyYcVHAAAIw/RBsAAAAwej63Ii/oFr2qwJjVkzTsn4v55YHFn5ZV1T+lUlZVUZIkWRZEkSIMKuLwh8P21zRQVk+nZzc8t6D9pbM9XXVTctq6fWNyZACnQQUHAMA4G8t0A4kGAADAhchijGMCz7yqcPEM366jPTHNYIzpbTXtrz7KGOuaPJMXBF/53ND0hRzPB6ctsLiPmopS51HGcQXRA3ndByzLmtP4x4Gf7c2D0WljcFAA/SDgAAA4/yHXAAAAuGD9be9bjGMcYxzHOI471a5NL1JTutnQmeqOf1TNkTh1lDEWqz3U9L+nhRe/WTednRjCczV2pl7Y1dHcnc7eywcYAgQcAADnLeQaAAAAsPCiS5jFBL4v42DMYizgEgv8kiRwPUmzujnBMa6t56NU4rSxr4N25FRCN9m7Vb2GyaZVrszqEQAMFgIOAIBxljGpPisPmMVHAwAAgFx349e//8rvfsY4xjHuoxaMfRNV8n1iYcAvi1xBQBI4FvaJXTGdYyzgGdRHxZMtmmlaxxqSacNMpi2LWRzHDHOUjgPgHNBkFABgQshKxoFoAwAAAM5o3drV7t7DXpVXZV6VeJfMSwIni5wi8aLASQIn8EzkOUHgBJ4TeI7nGM8xv1ukug+bxZhlse64bpjMsizDZGnD0g0rpZuptBXTjJ6k6S296JYf/WH8jhUuXAg4AAAmimFnHMg1AAAA4Jy+c/MVvvgRVebdCi+LvEviZIkXeSYKvCxyAs8kkec5RgEHxzGeMY5jPO/MNz4KOEzLMk1mWpZuWLrJKOBIpq2EZnQnjAX/uP7yL9wzbscJFzAEHAAAE8jgMw6EGgAAADBUJw/s3PKzuwKsQ5F4ReJl8aPaDUngJZETeMZznMhzAs+4j4o4OJ477RGcAYdhWYYj4NDSZjxldcX0a7/3+/K5aMMB4wABBwDAxDJAxoFQAwAAAEbu3jvXTrKOhfhOWeJFnpNFThA4WeB4nok8x/OcQIUbHOMYE05POE4LOEzLMC3dsNKGlTasZNrsTZqf/uaWybNWjNehwQUOAQcAwERkxxwINQAAAGA0/L/rv1TOV+WLXTzPKSInChzPcyLPBJ7j+3pwcBx3xh4cpmmZ1t8DjpRhpXRr+ifXFUxbVjhj+fgdE1zoEHAAAAAAAABcoNavXx/iO/PFzgKpq0DuEnkmCBxPhRsc47mP6jhsFmOmaVkWM0zLYkw3LF/Zxf7yi2esXjduxwDQBwEHAAAAAAAAMMZY18k9jLFozZ6eur1Uu8FxrLd2r30Db9lFlsV8ZRdZFjMtVn7ZneP3YgEyIeAAAAAAAAAAgJzHj/cLAAAAAAAAAAAYKQQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDzEHAAAAAAAAAAQM5DwAEAAAAAAAAAOQ8BBwAAAAAAAADkPAQcAAAAAAAAAJDz/n9vrRlR2J7Q4AAAAABJRU5ErkJggg==", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Total time: 40.9011s plan time: 1.3937s, sim_steps: 504/500, opt_steps: 85\n" ] } ], "source": [ "# initial controls\n", "ctrls = ctrl_ref[: config.horizon_steps]\n", "# buffers for saving info and trajectory\n", "info_list = []\n", "\n", "# jupyter display handle\n", "handle = display(Image(data=b''), display_id=True)\n", "\n", "# run viewer + control loop\n", "t_start = time.perf_counter()\n", "with run_viewer() as viewer:\n", " while viewer.is_running():\n", " t0 = time.perf_counter()\n", "\n", " # optimize using future reference window at control-rate (+1 lookahead)\n", " sim_step = int(np.round(mj_data.time / config.sim_dt))\n", " ref_slice = get_slice(\n", " ref_data, sim_step + 1, sim_step + config.horizon_steps + 1\n", " )\n", " ctrls, infos = optimize(config, env, ctrls, ref_slice)\n", "\n", " # step environment for ctrl_steps\n", " step_info = {\"qpos\": [], \"qvel\": [], \"time\": [], \"ctrl\": []}\n", " for i in range(config.ctrl_steps):\n", " # option 1: use mujoco step\n", " # mj_data.ctrl[:] = ctrls[i].detach().cpu().numpy()\n", " # mujoco.mj_step(mj_model, mj_data)\n", " # option 2: use warp step\n", " step_env(config, env, ctrls[i : i + 1])\n", " mj_data.qpos[:] = get_qpos(config, env)[0].detach().cpu().numpy()\n", " mj_data.qvel[:] = get_qvel(config, env)[0].detach().cpu().numpy()\n", " mj_data.ctrl[:] = ctrls[i].detach().cpu().numpy()\n", " mj_data.time += config.sim_dt\n", " if config.save_video and renderer is not None:\n", " if i % int(np.round(config.render_dt / config.sim_dt)) == 0:\n", " mj_data_ref.qpos[:] = (\n", " qpos_ref[sim_step + i].detach().cpu().numpy()\n", " )\n", " image = render_image(\n", " config, renderer, mj_model, mj_data, mj_data_ref\n", " )\n", " # update notebook image\n", " with io.BytesIO() as buf:\n", " imageio.imwrite(buf, image, format='PNG')\n", " image_bytes = buf.getvalue()\n", " handle.update(Image(data=image_bytes))\n", " images.append(image)\n", " if \"rerun\" in config.viewer:\n", " # manually log the state\n", " log_frame(\n", " mj_data,\n", " sim_time=mj_data.time,\n", " viewer_body_entity_and_ids=config.viewer_body_entity_and_ids,\n", " )\n", " step_info[\"qpos\"].append(mj_data.qpos.copy())\n", " step_info[\"qvel\"].append(mj_data.qvel.copy())\n", " step_info[\"time\"].append(mj_data.time)\n", " step_info[\"ctrl\"].append(mj_data.ctrl.copy())\n", " for k in step_info:\n", " step_info[k] = np.stack(step_info[k], axis=0)\n", " infos.update(step_info)\n", " # sync env state\n", " sync_env(config, env, mj_data)\n", "\n", " # receding horizon update\n", " sim_step = int(np.round(mj_data.time / config.sim_dt))\n", " prev_ctrl = ctrls[config.ctrl_steps :]\n", " new_ctrl = ctrl_ref[\n", " sim_step + prev_ctrl.shape[0] : sim_step\n", " + prev_ctrl.shape[0]\n", " + config.ctrl_steps\n", " ]\n", " ctrls = torch.cat([prev_ctrl, new_ctrl], dim=0)\n", "\n", " # sync viewer state and render\n", " mj_data.qpos[:] = get_qpos(config, env)[0].detach().cpu().numpy()\n", " mj_data.qvel[:] = get_qvel(config, env)[0].detach().cpu().numpy()\n", " mj_data_ref.qpos[:] = qpos_ref[sim_step].detach().cpu().numpy()\n", " update_viewer(config, viewer, mj_model, mj_data, mj_data_ref, infos)\n", "\n", " # progress\n", " t1 = time.perf_counter()\n", " rtr = config.ctrl_dt / (t1 - t0)\n", " print(\n", " f\"Realtime rate: {rtr:.2f}, plan time: {t1 - t0:.4f}s, sim_steps: {sim_step}/{config.max_sim_steps}, opt_steps: {infos['opt_steps'][0]}\",\n", " end=\"\\r\",\n", " )\n", "\n", " # record info/trajectory at control tick\n", " # rule out \"trace\"\n", " info_list.append({k: v for k, v in infos.items() if k != \"trace_sample\"})\n", "\n", " if sim_step >= config.max_sim_steps:\n", " break\n", "\n", " t_end = time.perf_counter()\n", " print(f\"Total time: {t_end - t_start:.4f}s\")\n" ] }, { "cell_type": "code", "execution_count": 13, "id": "397b0cb9", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# show videos from images\n", "media.show_video(images, fps=int(1 / config.render_dt))" ] } ], "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.12.12" } }, "nbformat": 4, "nbformat_minor": 5 }